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

annotate src/share/vm/oops/instanceKlass.cpp @ 13212:eb03a7335eb0

Use fixed instead of virtual register for target in far foreign call, since the register allocator does not support virtual registers to be used at call sites.

author	Christian Wimmer <christian.wimmer@oracle.com>
date	Mon, 02 Dec 2013 14:20:32 -0800
parents	096c224171c4
children	02f27ecb4f3a

rev	line source
0 a61af66fc99e Initial load duke parents: diff changeset	1 /*
7956 16fb9f942703 6479360: PrintClassHistogram improvements acorn parents: 7610 diff changeset	2 * Copyright (c) 1997, 2013, 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
3404 2d4b2b833d29 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);
3404 2d4b2b833d29 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 }
3404 2d4b2b833d29 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
3404 2d4b2b833d29 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.
2d4b2b833d29 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
2d4b2b833d29 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 }
3404 2d4b2b833d29 7033141: assert(has_cp_cache(i)) failed: oob coleenp parents: 2408 diff changeset	774 }
2d4b2b833d29 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
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1054 objArrayOop InstanceKlass::allocate_objArray(int n, int length, TRAPS) {
0 a61af66fc99e Initial load duke parents: diff changeset	1055 if (length < 0) THROW_0(vmSymbols::java_lang_NegativeArraySizeException());
a61af66fc99e Initial load duke parents: diff changeset	1056 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	1057 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	1058 JvmtiExport::post_array_size_exhausted();
0 a61af66fc99e Initial load duke parents: diff changeset	1059 THROW_OOP_0(Universe::out_of_memory_error_array_size());
a61af66fc99e Initial load duke parents: diff changeset	1060 }
a61af66fc99e Initial load duke parents: diff changeset	1061 int size = objArrayOopDesc::object_size(length);
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1062 Klass* ak = array_klass(n, CHECK_NULL);
0 a61af66fc99e Initial load duke parents: diff changeset	1063 KlassHandle h_ak (THREAD, ak);
a61af66fc99e Initial load duke parents: diff changeset	1064 objArrayOop o =
a61af66fc99e Initial load duke parents: diff changeset	1065 (objArrayOop)CollectedHeap::array_allocate(h_ak, size, length, CHECK_NULL);
a61af66fc99e Initial load duke parents: diff changeset	1066 return o;
a61af66fc99e Initial load duke parents: diff changeset	1067 }
a61af66fc99e Initial load duke parents: diff changeset	1068
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1069 instanceOop InstanceKlass::register_finalizer(instanceOop i, TRAPS) {
0 a61af66fc99e Initial load duke parents: diff changeset	1070 if (TraceFinalizerRegistration) {
a61af66fc99e Initial load duke parents: diff changeset	1071 tty->print("Registered ");
a61af66fc99e Initial load duke parents: diff changeset	1072 i->print_value_on(tty);
a61af66fc99e Initial load duke parents: diff changeset	1073 tty->print_cr(" (" INTPTR_FORMAT ") as finalizable", (address)i);
a61af66fc99e Initial load duke parents: diff changeset	1074 }
a61af66fc99e Initial load duke parents: diff changeset	1075 instanceHandle h_i(THREAD, i);
a61af66fc99e Initial load duke parents: diff changeset	1076 // Pass the handle as argument, JavaCalls::call expects oop as jobjects
a61af66fc99e Initial load duke parents: diff changeset	1077 JavaValue result(T_VOID);
a61af66fc99e Initial load duke parents: diff changeset	1078 JavaCallArguments args(h_i);
a61af66fc99e Initial load duke parents: diff changeset	1079 methodHandle mh (THREAD, Universe::finalizer_register_method());
a61af66fc99e Initial load duke parents: diff changeset	1080 JavaCalls::call(&result, mh, &args, CHECK_NULL);
a61af66fc99e Initial load duke parents: diff changeset	1081 return h_i();
a61af66fc99e Initial load duke parents: diff changeset	1082 }
a61af66fc99e Initial load duke parents: diff changeset	1083
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1084 instanceOop InstanceKlass::allocate_instance(TRAPS) {
0 a61af66fc99e Initial load duke parents: diff changeset	1085 bool has_finalizer_flag = has_finalizer(); // Query before possible GC
a61af66fc99e Initial load duke parents: diff changeset	1086 int size = size_helper(); // Query before forming handle.
a61af66fc99e Initial load duke parents: diff changeset	1087
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1088 KlassHandle h_k(THREAD, this);
0 a61af66fc99e Initial load duke parents: diff changeset	1089
a61af66fc99e Initial load duke parents: diff changeset	1090 instanceOop i;
a61af66fc99e Initial load duke parents: diff changeset	1091
a61af66fc99e Initial load duke parents: diff changeset	1092 i = (instanceOop)CollectedHeap::obj_allocate(h_k, size, CHECK_NULL);
a61af66fc99e Initial load duke parents: diff changeset	1093 if (has_finalizer_flag && !RegisterFinalizersAtInit) {
a61af66fc99e Initial load duke parents: diff changeset	1094 i = register_finalizer(i, CHECK_NULL);
a61af66fc99e Initial load duke parents: diff changeset	1095 }
a61af66fc99e Initial load duke parents: diff changeset	1096 return i;
a61af66fc99e Initial load duke parents: diff changeset	1097 }
a61af66fc99e Initial load duke parents: diff changeset	1098
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1099 void InstanceKlass::check_valid_for_instantiation(bool throwError, TRAPS) {
0 a61af66fc99e Initial load duke parents: diff changeset	1100 if (is_interface() \|\| is_abstract()) {
a61af66fc99e Initial load duke parents: diff changeset	1101 ResourceMark rm(THREAD);
a61af66fc99e Initial load duke parents: diff changeset	1102 THROW_MSG(throwError ? vmSymbols::java_lang_InstantiationError()
a61af66fc99e Initial load duke parents: diff changeset	1103 : vmSymbols::java_lang_InstantiationException(), external_name());
a61af66fc99e Initial load duke parents: diff changeset	1104 }
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1105 if (this == SystemDictionary::Class_klass()) {
0 a61af66fc99e Initial load duke parents: diff changeset	1106 ResourceMark rm(THREAD);
a61af66fc99e Initial load duke parents: diff changeset	1107 THROW_MSG(throwError ? vmSymbols::java_lang_IllegalAccessError()
a61af66fc99e Initial load duke parents: diff changeset	1108 : vmSymbols::java_lang_IllegalAccessException(), external_name());
a61af66fc99e Initial load duke parents: diff changeset	1109 }
a61af66fc99e Initial load duke parents: diff changeset	1110 }
a61af66fc99e Initial load duke parents: diff changeset	1111
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1112 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	1113 instanceKlassHandle this_oop(THREAD, this);
0 a61af66fc99e Initial load duke parents: diff changeset	1114 return array_klass_impl(this_oop, or_null, n, THREAD);
a61af66fc99e Initial load duke parents: diff changeset	1115 }
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 Klass* InstanceKlass::array_klass_impl(instanceKlassHandle this_oop, bool or_null, int n, TRAPS) {
0 a61af66fc99e Initial load duke parents: diff changeset	1118 if (this_oop->array_klasses() == NULL) {
a61af66fc99e Initial load duke parents: diff changeset	1119 if (or_null) return NULL;
a61af66fc99e Initial load duke parents: diff changeset	1120
a61af66fc99e Initial load duke parents: diff changeset	1121 ResourceMark rm;
a61af66fc99e Initial load duke parents: diff changeset	1122 JavaThread jt = (JavaThread )THREAD;
a61af66fc99e Initial load duke parents: diff changeset	1123 {
a61af66fc99e Initial load duke parents: diff changeset	1124 // Atomic creation of array_klasses
a61af66fc99e Initial load duke parents: diff changeset	1125 MutexLocker mc(Compile_lock, THREAD); // for vtables
a61af66fc99e Initial load duke parents: diff changeset	1126 MutexLocker ma(MultiArray_lock, THREAD);
a61af66fc99e Initial load duke parents: diff changeset	1127
a61af66fc99e Initial load duke parents: diff changeset	1128 // Check if update has already taken place
a61af66fc99e Initial load duke parents: diff changeset	1129 if (this_oop->array_klasses() == NULL) {
6831 d8ce2825b193 8000213: NPG: Should have renamed arrayKlass and typeArrayKlass coleenp parents: 6735 diff changeset	1130 Klass* k = ObjArrayKlass::allocate_objArray_klass(this_oop->class_loader_data(), 1, this_oop, CHECK_NULL);
0 a61af66fc99e Initial load duke parents: diff changeset	1131 this_oop->set_array_klasses(k);
a61af66fc99e Initial load duke parents: diff changeset	1132 }
a61af66fc99e Initial load duke parents: diff changeset	1133 }
a61af66fc99e Initial load duke parents: diff changeset	1134 }
a61af66fc99e Initial load duke parents: diff changeset	1135 // _this will always be set at this point
6831 d8ce2825b193 8000213: NPG: Should have renamed arrayKlass and typeArrayKlass coleenp parents: 6735 diff changeset	1136 ObjArrayKlass* oak = (ObjArrayKlass*)this_oop->array_klasses();
0 a61af66fc99e Initial load duke parents: diff changeset	1137 if (or_null) {
a61af66fc99e Initial load duke parents: diff changeset	1138 return oak->array_klass_or_null(n);
a61af66fc99e Initial load duke parents: diff changeset	1139 }
a61af66fc99e Initial load duke parents: diff changeset	1140 return oak->array_klass(n, CHECK_NULL);
a61af66fc99e Initial load duke parents: diff changeset	1141 }
a61af66fc99e Initial load duke parents: diff changeset	1142
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1143 Klass* InstanceKlass::array_klass_impl(bool or_null, TRAPS) {
0 a61af66fc99e Initial load duke parents: diff changeset	1144 return array_klass_impl(or_null, 1, THREAD);
a61af66fc99e Initial load duke parents: diff changeset	1145 }
a61af66fc99e Initial load duke parents: diff changeset	1146
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1147 void InstanceKlass::call_class_initializer(TRAPS) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1148 instanceKlassHandle ik (THREAD, this);
0 a61af66fc99e Initial load duke parents: diff changeset	1149 call_class_initializer_impl(ik, THREAD);
a61af66fc99e Initial load duke parents: diff changeset	1150 }
a61af66fc99e Initial load duke parents: diff changeset	1151
a61af66fc99e Initial load duke parents: diff changeset	1152 static int call_class_initializer_impl_counter = 0; // for debugging
a61af66fc99e Initial load duke parents: diff changeset	1153
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1154 Method* InstanceKlass::class_initializer() {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1155 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	1156 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	1157 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	1158 return clinit;
dbad0519a1c4 6845426: non-static <clinit> method with no args is called during the class initialization process kamg parents: 2227 diff changeset	1159 }
dbad0519a1c4 6845426: non-static <clinit> method with no args is called during the class initialization process kamg parents: 2227 diff changeset	1160 return NULL;
0 a61af66fc99e Initial load duke parents: diff changeset	1161 }
a61af66fc99e Initial load duke parents: diff changeset	1162
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1163 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	1164 if (ReplayCompiles &&
bd7a7ce2e264 6830717: replay of compilations would help with debugging minqi parents: 6934 diff changeset	1165 (ReplaySuppressInitializers == 1 \|\|
bd7a7ce2e264 6830717: replay of compilations would help with debugging minqi parents: 6934 diff changeset	1166 ReplaySuppressInitializers >= 2 && this_oop->class_loader() != NULL)) {
bd7a7ce2e264 6830717: replay of compilations would help with debugging minqi parents: 6934 diff changeset	1167 // 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	1168 return;
bd7a7ce2e264 6830717: replay of compilations would help with debugging minqi parents: 6934 diff changeset	1169 }
bd7a7ce2e264 6830717: replay of compilations would help with debugging minqi parents: 6934 diff changeset	1170
0 a61af66fc99e Initial load duke parents: diff changeset	1171 methodHandle h_method(THREAD, this_oop->class_initializer());
a61af66fc99e Initial load duke parents: diff changeset	1172 assert(!this_oop->is_initialized(), "we cannot initialize twice");
a61af66fc99e Initial load duke parents: diff changeset	1173 if (TraceClassInitialization) {
a61af66fc99e Initial load duke parents: diff changeset	1174 tty->print("%d Initializing ", call_class_initializer_impl_counter++);
a61af66fc99e Initial load duke parents: diff changeset	1175 this_oop->name()->print_value();
a61af66fc99e Initial load duke parents: diff changeset	1176 tty->print_cr("%s (" INTPTR_FORMAT ")", h_method() == NULL ? "(no method)" : "", (address)this_oop());
a61af66fc99e Initial load duke parents: diff changeset	1177 }
a61af66fc99e Initial load duke parents: diff changeset	1178 if (h_method() != NULL) {
a61af66fc99e Initial load duke parents: diff changeset	1179 JavaCallArguments args; // No arguments
a61af66fc99e Initial load duke parents: diff changeset	1180 JavaValue result(T_VOID);
a61af66fc99e Initial load duke parents: diff changeset	1181 JavaCalls::call(&result, h_method, &args, CHECK); // Static call (no args)
a61af66fc99e Initial load duke parents: diff changeset	1182 }
a61af66fc99e Initial load duke parents: diff changeset	1183 }
a61af66fc99e Initial load duke parents: diff changeset	1184
a61af66fc99e Initial load duke parents: diff changeset	1185
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1186 void InstanceKlass::mask_for(methodHandle method, int bci,
0 a61af66fc99e Initial load duke parents: diff changeset	1187 InterpreterOopMap* entry_for) {
a61af66fc99e Initial load duke parents: diff changeset	1188 // Dirty read, then double-check under a lock.
a61af66fc99e Initial load duke parents: diff changeset	1189 if (_oop_map_cache == NULL) {
a61af66fc99e Initial load duke parents: diff changeset	1190 // Otherwise, allocate a new one.
a61af66fc99e Initial load duke parents: diff changeset	1191 MutexLocker x(OopMapCacheAlloc_lock);
a61af66fc99e Initial load duke parents: diff changeset	1192 // First time use. Allocate a cache in C heap
a61af66fc99e Initial load duke parents: diff changeset	1193 if (_oop_map_cache == NULL) {
a61af66fc99e Initial load duke parents: diff changeset	1194 _oop_map_cache = new OopMapCache();
a61af66fc99e Initial load duke parents: diff changeset	1195 }
a61af66fc99e Initial load duke parents: diff changeset	1196 }
a61af66fc99e Initial load duke parents: diff changeset	1197 // _oop_map_cache is constant after init; lookup below does is own locking.
a61af66fc99e Initial load duke parents: diff changeset	1198 _oop_map_cache->lookup(method, bci, entry_for);
a61af66fc99e Initial load duke parents: diff changeset	1199 }
a61af66fc99e Initial load duke parents: diff changeset	1200
a61af66fc99e Initial load duke parents: diff changeset	1201
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1202 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	1203 for (JavaFieldStream fs(this); !fs.done(); fs.next()) {
3938 e6b1331a51d2 7086585: make Java field injection more flexible never parents: 3852 diff changeset	1204 Symbol* f_name = fs.name();
e6b1331a51d2 7086585: make Java field injection more flexible never parents: 3852 diff changeset	1205 Symbol* f_sig = fs.signature();
0 a61af66fc99e Initial load duke parents: diff changeset	1206 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	1207 fd->reinitialize(const_cast<InstanceKlass*>(this), fs.index());
0 a61af66fc99e Initial load duke parents: diff changeset	1208 return true;
a61af66fc99e Initial load duke parents: diff changeset	1209 }
a61af66fc99e Initial load duke parents: diff changeset	1210 }
a61af66fc99e Initial load duke parents: diff changeset	1211 return false;
a61af66fc99e Initial load duke parents: diff changeset	1212 }
a61af66fc99e Initial load duke parents: diff changeset	1213
a61af66fc99e Initial load duke parents: diff changeset	1214
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1215 Klass* InstanceKlass::find_interface_field(Symbol* name, Symbol* sig, fieldDescriptor* fd) const {
0 a61af66fc99e Initial load duke parents: diff changeset	1216 const int n = local_interfaces()->length();
a61af66fc99e Initial load duke parents: diff changeset	1217 for (int i = 0; i < n; i++) {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1218 Klass* intf1 = local_interfaces()->at(i);
6983 070d523b96a7 8001471: Klass::cast() does nothing hseigel parents: 6934 diff changeset	1219 assert(intf1->is_interface(), "just checking type");
0 a61af66fc99e Initial load duke parents: diff changeset	1220 // search for field in current interface
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1221 if (InstanceKlass::cast(intf1)->find_local_field(name, sig, fd)) {
0 a61af66fc99e Initial load duke parents: diff changeset	1222 assert(fd->is_static(), "interface field must be static");
a61af66fc99e Initial load duke parents: diff changeset	1223 return intf1;
a61af66fc99e Initial load duke parents: diff changeset	1224 }
a61af66fc99e Initial load duke parents: diff changeset	1225 // search for field in direct superinterfaces
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1226 Klass* intf2 = InstanceKlass::cast(intf1)->find_interface_field(name, sig, fd);
0 a61af66fc99e Initial load duke parents: diff changeset	1227 if (intf2 != NULL) return intf2;
a61af66fc99e Initial load duke parents: diff changeset	1228 }
a61af66fc99e Initial load duke parents: diff changeset	1229 // otherwise field lookup fails
a61af66fc99e Initial load duke parents: diff changeset	1230 return NULL;
a61af66fc99e Initial load duke parents: diff changeset	1231 }
a61af66fc99e Initial load duke parents: diff changeset	1232
a61af66fc99e Initial load duke parents: diff changeset	1233
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1234 Klass* InstanceKlass::find_field(Symbol* name, Symbol* sig, fieldDescriptor* fd) const {
0 a61af66fc99e Initial load duke parents: diff changeset	1235 // search order according to newest JVM spec (5.4.3.2, p.167).
a61af66fc99e Initial load duke parents: diff changeset	1236 // 1) search for field in current klass
a61af66fc99e Initial load duke parents: diff changeset	1237 if (find_local_field(name, sig, fd)) {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1238 return const_cast<InstanceKlass*>(this);
0 a61af66fc99e Initial load duke parents: diff changeset	1239 }
a61af66fc99e Initial load duke parents: diff changeset	1240 // 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	1241 { Klass* intf = find_interface_field(name, sig, fd);
0 a61af66fc99e Initial load duke parents: diff changeset	1242 if (intf != NULL) return intf;
a61af66fc99e Initial load duke parents: diff changeset	1243 }
a61af66fc99e Initial load duke parents: diff changeset	1244 // 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	1245 { Klass* supr = super();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1246 if (supr != NULL) return InstanceKlass::cast(supr)->find_field(name, sig, fd);
0 a61af66fc99e Initial load duke parents: diff changeset	1247 }
a61af66fc99e Initial load duke parents: diff changeset	1248 // 4) otherwise field lookup fails
a61af66fc99e Initial load duke parents: diff changeset	1249 return NULL;
a61af66fc99e Initial load duke parents: diff changeset	1250 }
a61af66fc99e Initial load duke parents: diff changeset	1251
a61af66fc99e Initial load duke parents: diff changeset	1252
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1253 Klass* InstanceKlass::find_field(Symbol* name, Symbol* sig, bool is_static, fieldDescriptor* fd) const {
0 a61af66fc99e Initial load duke parents: diff changeset	1254 // search order according to newest JVM spec (5.4.3.2, p.167).
a61af66fc99e Initial load duke parents: diff changeset	1255 // 1) search for field in current klass
a61af66fc99e Initial load duke parents: diff changeset	1256 if (find_local_field(name, sig, fd)) {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1257 if (fd->is_static() == is_static) return const_cast<InstanceKlass*>(this);
0 a61af66fc99e Initial load duke parents: diff changeset	1258 }
a61af66fc99e Initial load duke parents: diff changeset	1259 // 2) search for field recursively in direct superinterfaces
a61af66fc99e Initial load duke parents: diff changeset	1260 if (is_static) {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1261 Klass* intf = find_interface_field(name, sig, fd);
0 a61af66fc99e Initial load duke parents: diff changeset	1262 if (intf != NULL) return intf;
a61af66fc99e Initial load duke parents: diff changeset	1263 }
a61af66fc99e Initial load duke parents: diff changeset	1264 // 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	1265 { Klass* supr = super();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1266 if (supr != NULL) return InstanceKlass::cast(supr)->find_field(name, sig, is_static, fd);
0 a61af66fc99e Initial load duke parents: diff changeset	1267 }
a61af66fc99e Initial load duke parents: diff changeset	1268 // 4) otherwise field lookup fails
a61af66fc99e Initial load duke parents: diff changeset	1269 return NULL;
a61af66fc99e Initial load duke parents: diff changeset	1270 }
a61af66fc99e Initial load duke parents: diff changeset	1271
a61af66fc99e Initial load duke parents: diff changeset	1272
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1273 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	1274 for (JavaFieldStream fs(this); !fs.done(); fs.next()) {
3938 e6b1331a51d2 7086585: make Java field injection more flexible never parents: 3852 diff changeset	1275 if (fs.offset() == offset) {
12264 b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 12067 diff changeset	1276 fd->reinitialize(const_cast<InstanceKlass*>(this), fs.index());
0 a61af66fc99e Initial load duke parents: diff changeset	1277 if (fd->is_static() == is_static) return true;
a61af66fc99e Initial load duke parents: diff changeset	1278 }
a61af66fc99e Initial load duke parents: diff changeset	1279 }
a61af66fc99e Initial load duke parents: diff changeset	1280 return false;
a61af66fc99e Initial load duke parents: diff changeset	1281 }
a61af66fc99e Initial load duke parents: diff changeset	1282
a61af66fc99e Initial load duke parents: diff changeset	1283
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1284 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	1285 Klass* klass = const_cast<InstanceKlass*>(this);
0 a61af66fc99e Initial load duke parents: diff changeset	1286 while (klass != NULL) {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1287 if (InstanceKlass::cast(klass)->find_local_field_from_offset(offset, is_static, fd)) {
0 a61af66fc99e Initial load duke parents: diff changeset	1288 return true;
a61af66fc99e Initial load duke parents: diff changeset	1289 }
6983 070d523b96a7 8001471: Klass::cast() does nothing hseigel parents: 6934 diff changeset	1290 klass = klass->super();
0 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 void InstanceKlass::methods_do(void f(Method* method)) {
0 a61af66fc99e Initial load duke parents: diff changeset	1297 int len = methods()->length();
a61af66fc99e Initial load duke parents: diff changeset	1298 for (int index = 0; index < len; index++) {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1299 Method* m = methods()->at(index);
0 a61af66fc99e Initial load duke parents: diff changeset	1300 assert(m->is_method(), "must be method");
a61af66fc99e Initial load duke parents: diff changeset	1301 f(m);
a61af66fc99e Initial load duke parents: diff changeset	1302 }
a61af66fc99e Initial load duke parents: diff changeset	1303 }
a61af66fc99e Initial load duke parents: diff changeset	1304
2376 c7f3d0b4570f 7017732: move static fields into Class to prepare for perm gen removal never parents: 2357 diff changeset	1305
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1306 void InstanceKlass::do_local_static_fields(FieldClosure* cl) {
3938 e6b1331a51d2 7086585: make Java field injection more flexible never parents: 3852 diff changeset	1307 for (JavaFieldStream fs(this); !fs.done(); fs.next()) {
e6b1331a51d2 7086585: make Java field injection more flexible never parents: 3852 diff changeset	1308 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	1309 fieldDescriptor& fd = fs.field_descriptor();
3938 e6b1331a51d2 7086585: make Java field injection more flexible never parents: 3852 diff changeset	1310 cl->do_field(&fd);
e6b1331a51d2 7086585: make Java field injection more flexible never parents: 3852 diff changeset	1311 }
0 a61af66fc99e Initial load duke parents: diff changeset	1312 }
a61af66fc99e Initial load duke parents: diff changeset	1313 }
a61af66fc99e Initial load duke parents: diff changeset	1314
a61af66fc99e Initial load duke parents: diff changeset	1315
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1316 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	1317 instanceKlassHandle h_this(THREAD, this);
0 a61af66fc99e Initial load duke parents: diff changeset	1318 do_local_static_fields_impl(h_this, f, CHECK);
a61af66fc99e Initial load duke parents: diff changeset	1319 }
a61af66fc99e Initial load duke parents: diff changeset	1320
a61af66fc99e Initial load duke parents: diff changeset	1321
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1322 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	1323 for (JavaFieldStream fs(this_oop()); !fs.done(); fs.next()) {
e6b1331a51d2 7086585: make Java field injection more flexible never parents: 3852 diff changeset	1324 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	1325 fieldDescriptor& fd = fs.field_descriptor();
3938 e6b1331a51d2 7086585: make Java field injection more flexible never parents: 3852 diff changeset	1326 f(&fd, CHECK);
e6b1331a51d2 7086585: make Java field injection more flexible never parents: 3852 diff changeset	1327 }
0 a61af66fc99e Initial load duke parents: diff changeset	1328 }
a61af66fc99e Initial load duke parents: diff changeset	1329 }
a61af66fc99e Initial load duke parents: diff changeset	1330
a61af66fc99e Initial load duke parents: diff changeset	1331
44 52fed2ec0afb 6667620: (Escape Analysis) fix deoptimization for scalar replaced objects kvn parents: 0 diff changeset	1332 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	1333 return a[0] - b[0];
52fed2ec0afb 6667620: (Escape Analysis) fix deoptimization for scalar replaced objects kvn parents: 0 diff changeset	1334 }
52fed2ec0afb 6667620: (Escape Analysis) fix deoptimization for scalar replaced objects kvn parents: 0 diff changeset	1335
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1336 void InstanceKlass::do_nonstatic_fields(FieldClosure* cl) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1337 InstanceKlass* super = superklass();
0 a61af66fc99e Initial load duke parents: diff changeset	1338 if (super != NULL) {
a61af66fc99e Initial load duke parents: diff changeset	1339 super->do_nonstatic_fields(cl);
a61af66fc99e Initial load duke parents: diff changeset	1340 }
44 52fed2ec0afb 6667620: (Escape Analysis) fix deoptimization for scalar replaced objects kvn parents: 0 diff changeset	1341 fieldDescriptor fd;
3938 e6b1331a51d2 7086585: make Java field injection more flexible never parents: 3852 diff changeset	1342 int length = java_fields_count();
44 52fed2ec0afb 6667620: (Escape Analysis) fix deoptimization for scalar replaced objects kvn parents: 0 diff changeset	1343 // In DebugInfo nonstatic fields are sorted by offset.
6197 d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: 6038 diff changeset	1344 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	1345 int j = 0;
3938 e6b1331a51d2 7086585: make Java field injection more flexible never parents: 3852 diff changeset	1346 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	1347 fd.reinitialize(this, i);
44 52fed2ec0afb 6667620: (Escape Analysis) fix deoptimization for scalar replaced objects kvn parents: 0 diff changeset	1348 if (!fd.is_static()) {
52fed2ec0afb 6667620: (Escape Analysis) fix deoptimization for scalar replaced objects kvn parents: 0 diff changeset	1349 fields_sorted[j + 0] = fd.offset();
52fed2ec0afb 6667620: (Escape Analysis) fix deoptimization for scalar replaced objects kvn parents: 0 diff changeset	1350 fields_sorted[j + 1] = i;
52fed2ec0afb 6667620: (Escape Analysis) fix deoptimization for scalar replaced objects kvn parents: 0 diff changeset	1351 j += 2;
52fed2ec0afb 6667620: (Escape Analysis) fix deoptimization for scalar replaced objects kvn parents: 0 diff changeset	1352 }
0 a61af66fc99e Initial load duke parents: diff changeset	1353 }
44 52fed2ec0afb 6667620: (Escape Analysis) fix deoptimization for scalar replaced objects kvn parents: 0 diff changeset	1354 if (j > 0) {
52fed2ec0afb 6667620: (Escape Analysis) fix deoptimization for scalar replaced objects kvn parents: 0 diff changeset	1355 length = j;
52fed2ec0afb 6667620: (Escape Analysis) fix deoptimization for scalar replaced objects kvn parents: 0 diff changeset	1356 // _sort_Fn is defined in growableArray.hpp.
52fed2ec0afb 6667620: (Escape Analysis) fix deoptimization for scalar replaced objects kvn parents: 0 diff changeset	1357 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	1358 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	1359 fd.reinitialize(this, fields_sorted[i + 1]);
44 52fed2ec0afb 6667620: (Escape Analysis) fix deoptimization for scalar replaced objects kvn parents: 0 diff changeset	1360 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	1361 cl->do_field(&fd);
52fed2ec0afb 6667620: (Escape Analysis) fix deoptimization for scalar replaced objects kvn parents: 0 diff changeset	1362 }
52fed2ec0afb 6667620: (Escape Analysis) fix deoptimization for scalar replaced objects kvn parents: 0 diff changeset	1363 }
6197 d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: 6038 diff changeset	1364 FREE_C_HEAP_ARRAY(int, fields_sorted, mtClass);
0 a61af66fc99e Initial load duke parents: diff changeset	1365 }
a61af66fc99e Initial load duke parents: diff changeset	1366
a61af66fc99e Initial load duke parents: diff changeset	1367
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1368 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	1369 if (array_klasses() != NULL)
6831 d8ce2825b193 8000213: NPG: Should have renamed arrayKlass and typeArrayKlass coleenp parents: 6735 diff changeset	1370 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	1371 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1372
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1373 void InstanceKlass::array_klasses_do(void f(Klass* k)) {
0 a61af66fc99e Initial load duke parents: diff changeset	1374 if (array_klasses() != NULL)
6831 d8ce2825b193 8000213: NPG: Should have renamed arrayKlass and typeArrayKlass coleenp parents: 6735 diff changeset	1375 ArrayKlass::cast(array_klasses())->array_klasses_do(f);
0 a61af66fc99e Initial load duke parents: diff changeset	1376 }
a61af66fc99e Initial load duke parents: diff changeset	1377
a61af66fc99e Initial load duke parents: diff changeset	1378 #ifdef ASSERT
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1379 static int linear_search(Array<Method> methods, Symbol* name, Symbol* signature) {
0 a61af66fc99e Initial load duke parents: diff changeset	1380 int len = methods->length();
a61af66fc99e Initial load duke parents: diff changeset	1381 for (int index = 0; index < len; index++) {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1382 Method* m = methods->at(index);
0 a61af66fc99e Initial load duke parents: diff changeset	1383 assert(m->is_method(), "must be method");
a61af66fc99e Initial load duke parents: diff changeset	1384 if (m->signature() == signature && m->name() == name) {
a61af66fc99e Initial load duke parents: diff changeset	1385 return index;
a61af66fc99e Initial load duke parents: diff changeset	1386 }
a61af66fc99e Initial load duke parents: diff changeset	1387 }
a61af66fc99e Initial load duke parents: diff changeset	1388 return -1;
a61af66fc99e Initial load duke parents: diff changeset	1389 }
a61af66fc99e Initial load duke parents: diff changeset	1390 #endif
a61af66fc99e Initial load duke parents: diff changeset	1391
6934 4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6831 diff changeset	1392 static int binary_search(Array<Method> methods, Symbol* name) {
0 a61af66fc99e Initial load duke parents: diff changeset	1393 int len = methods->length();
a61af66fc99e Initial load duke parents: diff changeset	1394 // methods are sorted, so do binary search
a61af66fc99e Initial load duke parents: diff changeset	1395 int l = 0;
a61af66fc99e Initial load duke parents: diff changeset	1396 int h = len - 1;
a61af66fc99e Initial load duke parents: diff changeset	1397 while (l <= h) {
a61af66fc99e Initial load duke parents: diff changeset	1398 int mid = (l + h) >> 1;
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1399 Method* m = methods->at(mid);
0 a61af66fc99e Initial load duke parents: diff changeset	1400 assert(m->is_method(), "must be method");
a61af66fc99e Initial load duke parents: diff changeset	1401 int res = m->name()->fast_compare(name);
a61af66fc99e Initial load duke parents: diff changeset	1402 if (res == 0) {
6934 4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6831 diff changeset	1403 return mid;
0 a61af66fc99e Initial load duke parents: diff changeset	1404 } else if (res < 0) {
a61af66fc99e Initial load duke parents: diff changeset	1405 l = mid + 1;
a61af66fc99e Initial load duke parents: diff changeset	1406 } else {
a61af66fc99e Initial load duke parents: diff changeset	1407 h = mid - 1;
a61af66fc99e Initial load duke parents: diff changeset	1408 }
a61af66fc99e Initial load duke parents: diff changeset	1409 }
6934 4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6831 diff changeset	1410 return -1;
4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6831 diff changeset	1411 }
4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6831 diff changeset	1412
12823 ac9cb1d5a202 8009130: Lambda: Fix access controls, loader constraints. acorn parents: 12811 diff changeset	1413 // 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	1414 Method* InstanceKlass::find_method(Symbol* name, Symbol* signature) const {
4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6831 diff changeset	1415 return InstanceKlass::find_method(methods(), name, signature);
4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6831 diff changeset	1416 }
4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6831 diff changeset	1417
12823 ac9cb1d5a202 8009130: Lambda: Fix access controls, loader constraints. acorn parents: 12811 diff changeset	1418 // 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	1419 Method* InstanceKlass::find_method(
4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6831 diff changeset	1420 Array<Method> methods, Symbol* name, Symbol* signature) {
12823 ac9cb1d5a202 8009130: Lambda: Fix access controls, loader constraints. acorn parents: 12811 diff changeset	1421 int hit = find_method_index(methods, name, signature);
ac9cb1d5a202 8009130: Lambda: Fix access controls, loader constraints. acorn parents: 12811 diff changeset	1422 return hit >= 0 ? methods->at(hit): NULL;
ac9cb1d5a202 8009130: Lambda: Fix access controls, loader constraints. acorn parents: 12811 diff changeset	1423 }
ac9cb1d5a202 8009130: Lambda: Fix access controls, loader constraints. acorn parents: 12811 diff changeset	1424
ac9cb1d5a202 8009130: Lambda: Fix access controls, loader constraints. acorn parents: 12811 diff changeset	1425 // Used directly for default_methods to find the index into the
ac9cb1d5a202 8009130: Lambda: Fix access controls, loader constraints. acorn parents: 12811 diff changeset	1426 // default_vtable_indices, and indirectly by find_method
ac9cb1d5a202 8009130: Lambda: Fix access controls, loader constraints. acorn parents: 12811 diff changeset	1427 // 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	1428 // of the matching name/signature
ac9cb1d5a202 8009130: Lambda: Fix access controls, loader constraints. acorn parents: 12811 diff changeset	1429 int InstanceKlass::find_method_index(
ac9cb1d5a202 8009130: Lambda: Fix access controls, loader constraints. acorn parents: 12811 diff changeset	1430 Array<Method> methods, Symbol* name, Symbol* signature) {
6934 4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6831 diff changeset	1431 int hit = binary_search(methods, name);
4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6831 diff changeset	1432 if (hit != -1) {
4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6831 diff changeset	1433 Method* m = methods->at(hit);
4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6831 diff changeset	1434 // Do linear search to find matching signature. First, quick check
4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6831 diff changeset	1435 // for common case
12823 ac9cb1d5a202 8009130: Lambda: Fix access controls, loader constraints. acorn parents: 12811 diff changeset	1436 if (m->signature() == signature) return hit;
6934 4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6831 diff changeset	1437 // search downwards through overloaded methods
4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6831 diff changeset	1438 int i;
4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6831 diff changeset	1439 for (i = hit - 1; i >= 0; --i) {
4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6831 diff changeset	1440 Method* m = methods->at(i);
4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6831 diff changeset	1441 assert(m->is_method(), "must be method");
4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6831 diff changeset	1442 if (m->name() != name) break;
12823 ac9cb1d5a202 8009130: Lambda: Fix access controls, loader constraints. acorn parents: 12811 diff changeset	1443 if (m->signature() == signature) return i;
6934 4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6831 diff changeset	1444 }
4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6831 diff changeset	1445 // search upwards
4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6831 diff changeset	1446 for (i = hit + 1; i < methods->length(); ++i) {
4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6831 diff changeset	1447 Method* m = methods->at(i);
4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6831 diff changeset	1448 assert(m->is_method(), "must be method");
4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6831 diff changeset	1449 if (m->name() != name) break;
12823 ac9cb1d5a202 8009130: Lambda: Fix access controls, loader constraints. acorn parents: 12811 diff changeset	1450 if (m->signature() == signature) return i;
6934 4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6831 diff changeset	1451 }
4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6831 diff changeset	1452 // not found
0 a61af66fc99e Initial load duke parents: diff changeset	1453 #ifdef ASSERT
6934 4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6831 diff changeset	1454 int index = linear_search(methods, name, signature);
4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6831 diff changeset	1455 assert(index == -1, err_msg("binary search should have found entry %d", index));
0 a61af66fc99e Initial load duke parents: diff changeset	1456 #endif
6934 4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6831 diff changeset	1457 }
12823 ac9cb1d5a202 8009130: Lambda: Fix access controls, loader constraints. acorn parents: 12811 diff changeset	1458 return -1;
0 a61af66fc99e Initial load duke parents: diff changeset	1459 }
6934 4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6831 diff changeset	1460 int InstanceKlass::find_method_by_name(Symbol* name, int* end) {
4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6831 diff changeset	1461 return find_method_by_name(methods(), name, end);
4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6831 diff changeset	1462 }
4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6831 diff changeset	1463
4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6831 diff changeset	1464 int InstanceKlass::find_method_by_name(
4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6831 diff changeset	1465 Array<Method> methods, Symbol* name, int* end_ptr) {
4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6831 diff changeset	1466 assert(end_ptr != NULL, "just checking");
4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6831 diff changeset	1467 int start = binary_search(methods, name);
4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6831 diff changeset	1468 int end = start + 1;
4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6831 diff changeset	1469 if (start != -1) {
4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6831 diff changeset	1470 while (start - 1 >= 0 && (methods->at(start - 1))->name() == name) --start;
4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6831 diff changeset	1471 while (end < methods->length() && (methods->at(end))->name() == name) ++end;
4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6831 diff changeset	1472 *end_ptr = end;
4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6831 diff changeset	1473 return start;
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 return -1;
4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6831 diff changeset	1476 }
4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6831 diff changeset	1477
12823 ac9cb1d5a202 8009130: Lambda: Fix access controls, loader constraints. acorn parents: 12811 diff changeset	1478 // lookup_method searches both the local methods array and all superclasses methods arrays
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1479 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	1480 Klass* klass = const_cast<InstanceKlass*>(this);
0 a61af66fc99e Initial load duke parents: diff changeset	1481 while (klass != NULL) {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1482 Method* method = InstanceKlass::cast(klass)->find_method(name, signature);
0 a61af66fc99e Initial load duke parents: diff changeset	1483 if (method != NULL) return method;
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1484 klass = InstanceKlass::cast(klass)->super();
0 a61af66fc99e Initial load duke parents: diff changeset	1485 }
a61af66fc99e Initial load duke parents: diff changeset	1486 return NULL;
a61af66fc99e Initial load duke parents: diff changeset	1487 }
a61af66fc99e Initial load duke parents: diff changeset	1488
12823 ac9cb1d5a202 8009130: Lambda: Fix access controls, loader constraints. acorn parents: 12811 diff changeset	1489 // 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	1490 // Do NOT return private or static methods
ac9cb1d5a202 8009130: Lambda: Fix access controls, loader constraints. acorn parents: 12811 diff changeset	1491 Method* InstanceKlass::lookup_method_in_ordered_interfaces(Symbol* name,
ac9cb1d5a202 8009130: Lambda: Fix access controls, loader constraints. acorn parents: 12811 diff changeset	1492 Symbol* signature) const {
12828 d25557d03ec0 8026185: nsk/jvmit/GetMethodDeclaringClass/declcls001 failed acorn parents: 12823 diff changeset	1493 Method* m = NULL;
12823 ac9cb1d5a202 8009130: Lambda: Fix access controls, loader constraints. acorn parents: 12811 diff changeset	1494 if (default_methods() != NULL) {
ac9cb1d5a202 8009130: Lambda: Fix access controls, loader constraints. acorn parents: 12811 diff changeset	1495 m = find_method(default_methods(), name, signature);
ac9cb1d5a202 8009130: Lambda: Fix access controls, loader constraints. acorn parents: 12811 diff changeset	1496 }
ac9cb1d5a202 8009130: Lambda: Fix access controls, loader constraints. acorn parents: 12811 diff changeset	1497 // Look up interfaces
ac9cb1d5a202 8009130: Lambda: Fix access controls, loader constraints. acorn parents: 12811 diff changeset	1498 if (m == NULL) {
ac9cb1d5a202 8009130: Lambda: Fix access controls, loader constraints. acorn parents: 12811 diff changeset	1499 m = lookup_method_in_all_interfaces(name, signature);
ac9cb1d5a202 8009130: Lambda: Fix access controls, loader constraints. acorn parents: 12811 diff changeset	1500 }
ac9cb1d5a202 8009130: Lambda: Fix access controls, loader constraints. acorn parents: 12811 diff changeset	1501 return m;
ac9cb1d5a202 8009130: Lambda: Fix access controls, loader constraints. acorn parents: 12811 diff changeset	1502 }
ac9cb1d5a202 8009130: Lambda: Fix access controls, loader constraints. acorn parents: 12811 diff changeset	1503
0 a61af66fc99e Initial load duke parents: diff changeset	1504 // 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	1505 // 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	1506 // 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	1507 Method* InstanceKlass::lookup_method_in_all_interfaces(Symbol* name,
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	1508 Symbol* signature) const {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1509 Array<Klass> all_ifs = transitive_interfaces();
0 a61af66fc99e Initial load duke parents: diff changeset	1510 int num_ifs = all_ifs->length();
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1511 InstanceKlass *ik = NULL;
0 a61af66fc99e Initial load duke parents: diff changeset	1512 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	1513 ik = InstanceKlass::cast(all_ifs->at(i));
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1514 Method* m = ik->lookup_method(name, signature);
12318 36b97be47bde 8011311: Private interface methods. Default conflicts:ICCE. no erased_super_default. acorn parents: 12316 diff changeset	1515 if (m != NULL && m->is_public() && !m->is_static()) {
0 a61af66fc99e Initial load duke parents: diff changeset	1516 return m;
a61af66fc99e Initial load duke parents: diff changeset	1517 }
a61af66fc99e Initial load duke parents: diff changeset	1518 }
a61af66fc99e Initial load duke parents: diff changeset	1519 return NULL;
a61af66fc99e Initial load duke parents: diff changeset	1520 }
a61af66fc99e Initial load duke parents: diff changeset	1521
a61af66fc99e Initial load duke parents: diff changeset	1522 /* jni_id_for_impl for jfieldIds only */
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1523 JNIid* InstanceKlass::jni_id_for_impl(instanceKlassHandle this_oop, int offset) {
0 a61af66fc99e Initial load duke parents: diff changeset	1524 MutexLocker ml(JfieldIdCreation_lock);
a61af66fc99e Initial load duke parents: diff changeset	1525 // Retry lookup after we got the lock
a61af66fc99e Initial load duke parents: diff changeset	1526 JNIid* probe = this_oop->jni_ids() == NULL ? NULL : this_oop->jni_ids()->find(offset);
a61af66fc99e Initial load duke parents: diff changeset	1527 if (probe == NULL) {
a61af66fc99e Initial load duke parents: diff changeset	1528 // Slow case, allocate new static field identifier
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1529 probe = new JNIid(this_oop(), offset, this_oop->jni_ids());
0 a61af66fc99e Initial load duke parents: diff changeset	1530 this_oop->set_jni_ids(probe);
a61af66fc99e Initial load duke parents: diff changeset	1531 }
a61af66fc99e Initial load duke parents: diff changeset	1532 return probe;
a61af66fc99e Initial load duke parents: diff changeset	1533 }
a61af66fc99e Initial load duke parents: diff changeset	1534
a61af66fc99e Initial load duke parents: diff changeset	1535
a61af66fc99e Initial load duke parents: diff changeset	1536 /* jni_id_for for jfieldIds only */
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1537 JNIid* InstanceKlass::jni_id_for(int offset) {
0 a61af66fc99e Initial load duke parents: diff changeset	1538 JNIid* probe = jni_ids() == NULL ? NULL : jni_ids()->find(offset);
a61af66fc99e Initial load duke parents: diff changeset	1539 if (probe == NULL) {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1540 probe = jni_id_for_impl(this, offset);
0 a61af66fc99e Initial load duke parents: diff changeset	1541 }
a61af66fc99e Initial load duke parents: diff changeset	1542 return probe;
a61af66fc99e Initial load duke parents: diff changeset	1543 }
a61af66fc99e Initial load duke parents: diff changeset	1544
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1545 u2 InstanceKlass::enclosing_method_data(int offset) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1546 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	1547 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	1548 return 0;
f7c4174b33ba 7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field. jiangli parents: 4739 diff changeset	1549 }
f7c4174b33ba 7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field. jiangli parents: 4739 diff changeset	1550 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	1551 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	1552 return 0;
f7c4174b33ba 7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field. jiangli parents: 4739 diff changeset	1553 } else {
f7c4174b33ba 7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field. jiangli parents: 4739 diff changeset	1554 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	1555 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	1556 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	1557 }
f7c4174b33ba 7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field. jiangli parents: 4739 diff changeset	1558 }
f7c4174b33ba 7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field. jiangli parents: 4739 diff changeset	1559
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1560 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	1561 u2 method_index) {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1562 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	1563 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	1564 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	1565 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	1566 int index = length - enclosing_method_attribute_size;
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1567 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	1568 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	1569 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	1570 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	1571 }
f7c4174b33ba 7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field. jiangli parents: 4739 diff changeset	1572 }
0 a61af66fc99e Initial load duke parents: diff changeset	1573
a61af66fc99e Initial load duke parents: diff changeset	1574 // Lookup or create a jmethodID.
977 74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization dcubed parents: 974 diff changeset	1575 // 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	1576 // 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	1577 // and/or other cache consistency problems.
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization dcubed parents: 974 diff changeset	1578 //
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1579 jmethodID InstanceKlass::get_jmethod_id(instanceKlassHandle ik_h, methodHandle method_h) {
0 a61af66fc99e Initial load duke parents: diff changeset	1580 size_t idnum = (size_t)method_h->method_idnum();
a61af66fc99e Initial load duke parents: diff changeset	1581 jmethodID* jmeths = ik_h->methods_jmethod_ids_acquire();
a61af66fc99e Initial load duke parents: diff changeset	1582 size_t length = 0;
a61af66fc99e Initial load duke parents: diff changeset	1583 jmethodID id = NULL;
977 74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization dcubed parents: 974 diff changeset	1584
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization dcubed parents: 974 diff changeset	1585 // 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	1586 // 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	1587 // 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	1588 // 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	1589 // 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	1590 // 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	1591 // 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	1592 // 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	1593 // 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	1594 // 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	1595 // generally acquired in those two cases.
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization dcubed parents: 974 diff changeset	1596 //
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization dcubed parents: 974 diff changeset	1597 // 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	1598 // 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	1599 // 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	1600 // 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	1601 // acquired when the RedefineClasses() API has been used.
0 a61af66fc99e Initial load duke parents: diff changeset	1602
977 74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization dcubed parents: 974 diff changeset	1603 if (jmeths != NULL) {
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization dcubed parents: 974 diff changeset	1604 // the cache already exists
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization dcubed parents: 974 diff changeset	1605 if (!ik_h->idnum_can_increment()) {
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization dcubed parents: 974 diff changeset	1606 // 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	1607 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	1608 } else {
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization dcubed parents: 974 diff changeset	1609 // 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	1610 if (Threads::number_of_threads() == 0 \|\|
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization dcubed parents: 974 diff changeset	1611 SafepointSynchronize::is_at_safepoint()) {
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization dcubed parents: 974 diff changeset	1612 // 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	1613 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	1614 } else {
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization dcubed parents: 974 diff changeset	1615 MutexLocker ml(JmethodIdCreation_lock);
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization dcubed parents: 974 diff changeset	1616 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	1617 }
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization dcubed parents: 974 diff changeset	1618 }
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization dcubed parents: 974 diff changeset	1619 }
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization dcubed parents: 974 diff changeset	1620 // implied else:
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization dcubed parents: 974 diff changeset	1621 // we need to allocate a cache so default length and id values are good
0 a61af66fc99e Initial load duke parents: diff changeset	1622
977 74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization dcubed parents: 974 diff changeset	1623 if (jmeths == NULL \|\| // no cache yet
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization dcubed parents: 974 diff changeset	1624 length <= idnum \|\| // cache is too short
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization dcubed parents: 974 diff changeset	1625 id == NULL) { // cache doesn't contain entry
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 // 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	1628 // 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	1629 // 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	1630 // 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	1631 // to free after the lock is dropped.
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization dcubed parents: 974 diff changeset	1632 jmethodID to_dealloc_id = NULL;
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization dcubed parents: 974 diff changeset	1633 jmethodID* to_dealloc_jmeths = NULL;
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization dcubed parents: 974 diff changeset	1634
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization dcubed parents: 974 diff changeset	1635 // may not allocate new_jmeths or use it if we allocate it
0 a61af66fc99e Initial load duke parents: diff changeset	1636 jmethodID* new_jmeths = NULL;
a61af66fc99e Initial load duke parents: diff changeset	1637 if (length <= idnum) {
977 74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization dcubed parents: 974 diff changeset	1638 // allocate a new cache that might be used
0 a61af66fc99e Initial load duke parents: diff changeset	1639 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	1640 new_jmeths = NEW_C_HEAP_ARRAY(jmethodID, size+1, mtClass);
0 a61af66fc99e Initial load duke parents: diff changeset	1641 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	1642 // 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	1643 new_jmeths[0] = (jmethodID)size;
0 a61af66fc99e Initial load duke parents: diff changeset	1644 }
a61af66fc99e Initial load duke parents: diff changeset	1645
977 74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization dcubed parents: 974 diff changeset	1646 // allocate a new jmethodID that might be used
0 a61af66fc99e Initial load duke parents: diff changeset	1647 jmethodID new_id = NULL;
a61af66fc99e Initial load duke parents: diff changeset	1648 if (method_h->is_old() && !method_h->is_obsolete()) {
a61af66fc99e Initial load duke parents: diff changeset	1649 // 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	1650 Method* current_method = ik_h->method_with_idnum((int)idnum);
0 a61af66fc99e Initial load duke parents: diff changeset	1651 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	1652 new_id = Method::make_jmethod_id(ik_h->class_loader_data(), current_method);
0 a61af66fc99e Initial load duke parents: diff changeset	1653 } else {
a61af66fc99e Initial load duke parents: diff changeset	1654 // It is the current version of the method or an obsolete method,
a61af66fc99e Initial load duke parents: diff changeset	1655 // use the version passed in
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1656 new_id = Method::make_jmethod_id(ik_h->class_loader_data(), method_h());
0 a61af66fc99e Initial load duke parents: diff changeset	1657 }
a61af66fc99e Initial load duke parents: diff changeset	1658
977 74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization dcubed parents: 974 diff changeset	1659 if (Threads::number_of_threads() == 0 \|\|
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization dcubed parents: 974 diff changeset	1660 SafepointSynchronize::is_at_safepoint()) {
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization dcubed parents: 974 diff changeset	1661 // 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	1662 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	1663 &to_dealloc_id, &to_dealloc_jmeths);
49 31000d79ec71 6453355: 4/4 new No_Safepoint_Verifier uses fail during GC dcubed parents: 47 diff changeset	1664 } else {
0 a61af66fc99e Initial load duke parents: diff changeset	1665 MutexLocker ml(JmethodIdCreation_lock);
977 74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization dcubed parents: 974 diff changeset	1666 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	1667 &to_dealloc_id, &to_dealloc_jmeths);
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization dcubed parents: 974 diff changeset	1668 }
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization dcubed parents: 974 diff changeset	1669
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization dcubed parents: 974 diff changeset	1670 // 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	1671 // 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	1672 if (to_dealloc_jmeths != NULL) {
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization dcubed parents: 974 diff changeset	1673 FreeHeap(to_dealloc_jmeths);
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization dcubed parents: 974 diff changeset	1674 }
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization dcubed parents: 974 diff changeset	1675 // 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	1676 if (to_dealloc_id != NULL) {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1677 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	1678 }
31000d79ec71 6453355: 4/4 new No_Safepoint_Verifier uses fail during GC dcubed parents: 47 diff changeset	1679 }
31000d79ec71 6453355: 4/4 new No_Safepoint_Verifier uses fail during GC dcubed parents: 47 diff changeset	1680 return id;
31000d79ec71 6453355: 4/4 new No_Safepoint_Verifier uses fail during GC dcubed parents: 47 diff changeset	1681 }
0 a61af66fc99e Initial load duke parents: diff changeset	1682
49 31000d79ec71 6453355: 4/4 new No_Safepoint_Verifier uses fail during GC dcubed parents: 47 diff changeset	1683
977 74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization dcubed parents: 974 diff changeset	1684 // 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	1685 // 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	1686 // 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	1687 // the VMThread or have cache consistency issues.
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization dcubed parents: 974 diff changeset	1688 //
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1689 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	1690 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	1691 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	1692 jmethodID** to_dealloc_jmeths_p) {
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization dcubed parents: 974 diff changeset	1693 assert(new_id != NULL, "sanity check");
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization dcubed parents: 974 diff changeset	1694 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	1695 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	1696 assert(Threads::number_of_threads() == 0 \|\|
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization dcubed parents: 974 diff changeset	1697 SafepointSynchronize::is_at_safepoint() \|\|
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization dcubed parents: 974 diff changeset	1698 JmethodIdCreation_lock->owned_by_self(), "sanity check");
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 // 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	1701 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	1702 jmethodID id = NULL;
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization dcubed parents: 974 diff changeset	1703 size_t length = 0;
0 a61af66fc99e Initial load duke parents: diff changeset	1704
977 74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization dcubed parents: 974 diff changeset	1705 if (jmeths == NULL \|\| // no cache yet
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization dcubed parents: 974 diff changeset	1706 (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	1707 if (jmeths != NULL) {
977 74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization dcubed parents: 974 diff changeset	1708 // 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	1709 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	1710 new_jmeths[index+1] = jmeths[index+1];
0 a61af66fc99e Initial load duke parents: diff changeset	1711 }
977 74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization dcubed parents: 974 diff changeset	1712 *to_dealloc_jmeths_p = jmeths; // save old cache for later delete
0 a61af66fc99e Initial load duke parents: diff changeset	1713 }
49 31000d79ec71 6453355: 4/4 new No_Safepoint_Verifier uses fail during GC dcubed parents: 47 diff changeset	1714 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	1715 } else {
977 74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization dcubed parents: 974 diff changeset	1716 // 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	1717 id = jmeths[idnum+1];
977 74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization dcubed parents: 974 diff changeset	1718 *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	1719 }
31000d79ec71 6453355: 4/4 new No_Safepoint_Verifier uses fail during GC dcubed parents: 47 diff changeset	1720 if (id == NULL) {
977 74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization dcubed parents: 974 diff changeset	1721 // 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	1722 // 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	1723 // 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	1724 // 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	1725 id = new_id;
977 74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization dcubed parents: 974 diff changeset	1726
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization dcubed parents: 974 diff changeset	1727 // 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	1728 // 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	1729 // in the cache.
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization dcubed parents: 974 diff changeset	1730 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	1731 } else {
977 74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization dcubed parents: 974 diff changeset	1732 *to_dealloc_id_p = new_id; // save new id for later delete
0 a61af66fc99e Initial load duke parents: diff changeset	1733 }
a61af66fc99e Initial load duke parents: diff changeset	1734 return id;
a61af66fc99e Initial load duke parents: diff changeset	1735 }
a61af66fc99e Initial load duke parents: diff changeset	1736
a61af66fc99e Initial load duke parents: diff changeset	1737
977 74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization dcubed parents: 974 diff changeset	1738 // 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	1739 // 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	1740 //
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1741 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	1742 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	1743 assert(cache != NULL, "sanity check");
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization dcubed parents: 974 diff changeset	1744 assert(length_p != NULL, "sanity check");
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization dcubed parents: 974 diff changeset	1745 assert(id_p != NULL, "sanity check");
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization dcubed parents: 974 diff changeset	1746
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization dcubed parents: 974 diff changeset	1747 // 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	1748 *length_p = (size_t)cache[0];
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization dcubed parents: 974 diff changeset	1749 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	1750 *id_p = NULL;
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization dcubed parents: 974 diff changeset	1751 } else {
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization dcubed parents: 974 diff changeset	1752 *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	1753 }
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization dcubed parents: 974 diff changeset	1754 }
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization dcubed parents: 974 diff changeset	1755
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization dcubed parents: 974 diff changeset	1756
0 a61af66fc99e Initial load duke parents: diff changeset	1757 // 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	1758 jmethodID InstanceKlass::jmethod_id_or_null(Method* method) {
0 a61af66fc99e Initial load duke parents: diff changeset	1759 size_t idnum = (size_t)method->method_idnum();
a61af66fc99e Initial load duke parents: diff changeset	1760 jmethodID* jmeths = methods_jmethod_ids_acquire();
a61af66fc99e Initial load duke parents: diff changeset	1761 size_t length; // length assigned as debugging crumb
a61af66fc99e Initial load duke parents: diff changeset	1762 jmethodID id = NULL;
977 74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization dcubed parents: 974 diff changeset	1763 if (jmeths != NULL && // If there is a cache
0 a61af66fc99e Initial load duke parents: diff changeset	1764 (length = (size_t)jmeths[0]) > idnum) { // and if it is long enough,
a61af66fc99e Initial load duke parents: diff changeset	1765 id = jmeths[idnum+1]; // Look up the id (may be NULL)
a61af66fc99e Initial load duke parents: diff changeset	1766 }
a61af66fc99e Initial load duke parents: diff changeset	1767 return id;
a61af66fc99e Initial load duke parents: diff changeset	1768 }
a61af66fc99e Initial load duke parents: diff changeset	1769
a61af66fc99e Initial load duke parents: diff changeset	1770
a61af66fc99e Initial load duke parents: diff changeset	1771 //
a61af66fc99e Initial load duke parents: diff changeset	1772 // 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: 3404 diff changeset	1773 // are dependent on the changes that were passed in and mark them for
0 a61af66fc99e Initial load duke parents: diff changeset	1774 // deoptimization. Returns the number of nmethods found.
a61af66fc99e Initial load duke parents: diff changeset	1775 //
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1776 int InstanceKlass::mark_dependent_nmethods(DepChange& changes) {
0 a61af66fc99e Initial load duke parents: diff changeset	1777 assert_locked_or_safepoint(CodeCache_lock);
a61af66fc99e Initial load duke parents: diff changeset	1778 int found = 0;
a61af66fc99e Initial load duke parents: diff changeset	1779 nmethodBucket* b = _dependencies;
a61af66fc99e Initial load duke parents: diff changeset	1780 while (b != NULL) {
a61af66fc99e Initial load duke parents: diff changeset	1781 nmethod* nm = b->get_nmethod();
a61af66fc99e Initial load duke parents: diff changeset	1782 // since dependencies aren't removed until an nmethod becomes a zombie,
a61af66fc99e Initial load duke parents: diff changeset	1783 // the dependency list may contain nmethods which aren't alive.
a61af66fc99e Initial load duke parents: diff changeset	1784 if (nm->is_alive() && !nm->is_marked_for_deoptimization() && nm->check_dependency_on(changes)) {
a61af66fc99e Initial load duke parents: diff changeset	1785 if (TraceDependencies) {
a61af66fc99e Initial load duke parents: diff changeset	1786 ResourceMark rm;
a61af66fc99e Initial load duke parents: diff changeset	1787 tty->print_cr("Marked for deoptimization");
a61af66fc99e Initial load duke parents: diff changeset	1788 tty->print_cr(" context = %s", this->external_name());
a61af66fc99e Initial load duke parents: diff changeset	1789 changes.print();
a61af66fc99e Initial load duke parents: diff changeset	1790 nm->print();
a61af66fc99e Initial load duke parents: diff changeset	1791 nm->print_dependencies();
a61af66fc99e Initial load duke parents: diff changeset	1792 }
a61af66fc99e Initial load duke parents: diff changeset	1793 nm->mark_for_deoptimization();
a61af66fc99e Initial load duke parents: diff changeset	1794 found++;
a61af66fc99e Initial load duke parents: diff changeset	1795 }
a61af66fc99e Initial load duke parents: diff changeset	1796 b = b->next();
a61af66fc99e Initial load duke parents: diff changeset	1797 }
a61af66fc99e Initial load duke parents: diff changeset	1798 return found;
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 //
a61af66fc99e Initial load duke parents: diff changeset	1803 // Add an nmethodBucket to the list of dependencies for this nmethod.
a61af66fc99e Initial load duke parents: diff changeset	1804 // It's possible that an nmethod has multiple dependencies on this klass
a61af66fc99e Initial load duke parents: diff changeset	1805 // so a count is kept for each bucket to guarantee that creation and
a61af66fc99e Initial load duke parents: diff changeset	1806 // deletion of dependencies is consistent.
a61af66fc99e Initial load duke parents: diff changeset	1807 //
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1808 void InstanceKlass::add_dependent_nmethod(nmethod* nm) {
0 a61af66fc99e Initial load duke parents: diff changeset	1809 assert_locked_or_safepoint(CodeCache_lock);
a61af66fc99e Initial load duke parents: diff changeset	1810 nmethodBucket* b = _dependencies;
a61af66fc99e Initial load duke parents: diff changeset	1811 nmethodBucket* last = NULL;
a61af66fc99e Initial load duke parents: diff changeset	1812 while (b != NULL) {
a61af66fc99e Initial load duke parents: diff changeset	1813 if (nm == b->get_nmethod()) {
a61af66fc99e Initial load duke parents: diff changeset	1814 b->increment();
a61af66fc99e Initial load duke parents: diff changeset	1815 return;
a61af66fc99e Initial load duke parents: diff changeset	1816 }
a61af66fc99e Initial load duke parents: diff changeset	1817 b = b->next();
a61af66fc99e Initial load duke parents: diff changeset	1818 }
a61af66fc99e Initial load duke parents: diff changeset	1819 _dependencies = new nmethodBucket(nm, _dependencies);
a61af66fc99e Initial load duke parents: diff changeset	1820 }
a61af66fc99e Initial load duke parents: diff changeset	1821
a61af66fc99e Initial load duke parents: diff changeset	1822
a61af66fc99e Initial load duke parents: diff changeset	1823 //
a61af66fc99e Initial load duke parents: diff changeset	1824 // Decrement count of the nmethod in the dependency list and remove
a61af66fc99e Initial load duke parents: diff changeset	1825 // the bucket competely when the count goes to 0. This method must
a61af66fc99e Initial load duke parents: diff changeset	1826 // find a corresponding bucket otherwise there's a bug in the
a61af66fc99e Initial load duke parents: diff changeset	1827 // recording of dependecies.
a61af66fc99e Initial load duke parents: diff changeset	1828 //
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1829 void InstanceKlass::remove_dependent_nmethod(nmethod* nm) {
0 a61af66fc99e Initial load duke parents: diff changeset	1830 assert_locked_or_safepoint(CodeCache_lock);
a61af66fc99e Initial load duke parents: diff changeset	1831 nmethodBucket* b = _dependencies;
a61af66fc99e Initial load duke parents: diff changeset	1832 nmethodBucket* last = NULL;
a61af66fc99e Initial load duke parents: diff changeset	1833 while (b != NULL) {
a61af66fc99e Initial load duke parents: diff changeset	1834 if (nm == b->get_nmethod()) {
a61af66fc99e Initial load duke parents: diff changeset	1835 if (b->decrement() == 0) {
a61af66fc99e Initial load duke parents: diff changeset	1836 if (last == NULL) {
a61af66fc99e Initial load duke parents: diff changeset	1837 _dependencies = b->next();
a61af66fc99e Initial load duke parents: diff changeset	1838 } else {
a61af66fc99e Initial load duke parents: diff changeset	1839 last->set_next(b->next());
a61af66fc99e Initial load duke parents: diff changeset	1840 }
a61af66fc99e Initial load duke parents: diff changeset	1841 delete b;
a61af66fc99e Initial load duke parents: diff changeset	1842 }
a61af66fc99e Initial load duke parents: diff changeset	1843 return;
a61af66fc99e Initial load duke parents: diff changeset	1844 }
a61af66fc99e Initial load duke parents: diff changeset	1845 last = b;
a61af66fc99e Initial load duke parents: diff changeset	1846 b = b->next();
a61af66fc99e Initial load duke parents: diff changeset	1847 }
a61af66fc99e Initial load duke parents: diff changeset	1848 #ifdef ASSERT
a61af66fc99e Initial load duke parents: diff changeset	1849 tty->print_cr("### %s can't find dependent nmethod:", this->external_name());
a61af66fc99e Initial load duke parents: diff changeset	1850 nm->print();
a61af66fc99e Initial load duke parents: diff changeset	1851 #endif // ASSERT
a61af66fc99e Initial load duke parents: diff changeset	1852 ShouldNotReachHere();
a61af66fc99e Initial load duke parents: diff changeset	1853 }
a61af66fc99e Initial load duke parents: diff changeset	1854
a61af66fc99e Initial load duke parents: diff changeset	1855
a61af66fc99e Initial load duke parents: diff changeset	1856 #ifndef PRODUCT
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1857 void InstanceKlass::print_dependent_nmethods(bool verbose) {
0 a61af66fc99e Initial load duke parents: diff changeset	1858 nmethodBucket* b = _dependencies;
a61af66fc99e Initial load duke parents: diff changeset	1859 int idx = 0;
a61af66fc99e Initial load duke parents: diff changeset	1860 while (b != NULL) {
a61af66fc99e Initial load duke parents: diff changeset	1861 nmethod* nm = b->get_nmethod();
a61af66fc99e Initial load duke parents: diff changeset	1862 tty->print("[%d] count=%d { ", idx++, b->count());
a61af66fc99e Initial load duke parents: diff changeset	1863 if (!verbose) {
a61af66fc99e Initial load duke parents: diff changeset	1864 nm->print_on(tty, "nmethod");
a61af66fc99e Initial load duke parents: diff changeset	1865 tty->print_cr(" } ");
a61af66fc99e Initial load duke parents: diff changeset	1866 } else {
a61af66fc99e Initial load duke parents: diff changeset	1867 nm->print();
a61af66fc99e Initial load duke parents: diff changeset	1868 nm->print_dependencies();
a61af66fc99e Initial load duke parents: diff changeset	1869 tty->print_cr("--- } ");
a61af66fc99e Initial load duke parents: diff changeset	1870 }
a61af66fc99e Initial load duke parents: diff changeset	1871 b = b->next();
a61af66fc99e Initial load duke parents: diff changeset	1872 }
a61af66fc99e Initial load duke parents: diff changeset	1873 }
a61af66fc99e Initial load duke parents: diff changeset	1874
a61af66fc99e Initial load duke parents: diff changeset	1875
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1876 bool InstanceKlass::is_dependent_nmethod(nmethod* nm) {
0 a61af66fc99e Initial load duke parents: diff changeset	1877 nmethodBucket* b = _dependencies;
a61af66fc99e Initial load duke parents: diff changeset	1878 while (b != NULL) {
a61af66fc99e Initial load duke parents: diff changeset	1879 if (nm == b->get_nmethod()) {
a61af66fc99e Initial load duke parents: diff changeset	1880 return true;
a61af66fc99e Initial load duke parents: diff changeset	1881 }
a61af66fc99e Initial load duke parents: diff changeset	1882 b = b->next();
a61af66fc99e Initial load duke parents: diff changeset	1883 }
a61af66fc99e Initial load duke parents: diff changeset	1884 return false;
a61af66fc99e Initial load duke parents: diff changeset	1885 }
a61af66fc99e Initial load duke parents: diff changeset	1886 #endif //PRODUCT
a61af66fc99e Initial load duke parents: diff changeset	1887
a61af66fc99e Initial load duke parents: diff changeset	1888
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1889 // Garbage collection
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1890
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	1891 #ifdef ASSERT
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	1892 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	1893 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	1894 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	1895 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	1896 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	1897 }
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	1898 }
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	1899 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	1900 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	1901 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	1902 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	1903 assert(Universe::heap()->is_in_closed_subset(o),
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1904 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	1905 }
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	1906 }
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	1907 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	1908 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	1909 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	1910 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	1911 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	1912 }
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	1913 }
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	1914 template <class T> void assert_nothing(T *p) {}
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	1915
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	1916 #else
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	1917 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	1918 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	1919 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	1920 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	1921 #endif // ASSERT
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	1922
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	1923 //
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	1924 // 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	1925 // 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	1926 //
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	1927 // Parameters are:
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	1928 // 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	1929 // 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	1930 // 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	1931 // 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	1932 // 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	1933 // it a template function)
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	1934 // 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	1935 // doesn't matter when enabled.
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	1936 #define InstanceKlass_SPECIALIZED_OOP_ITERATE( \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	1937 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	1938 assert_fn) \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	1939 { \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	1940 T* p = (T*)(start_p); \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	1941 T* const end = p + (count); \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	1942 while (p < end) { \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	1943 (assert_fn)(p); \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	1944 do_oop; \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	1945 ++p; \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	1946 } \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	1947 }
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	1948
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	1949 #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	1950 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	1951 assert_fn) \
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 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	1954 T* p = start + (count); \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	1955 while (start < p) { \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	1956 --p; \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	1957 (assert_fn)(p); \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	1958 do_oop; \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	1959 } \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	1960 }
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	1961
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	1962 #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	1963 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	1964 do_oop, assert_fn) \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	1965 { \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	1966 T* const l = (T*)(low); \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	1967 T* const h = (T*)(high); \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	1968 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	1969 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	1970 "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	1971 T* p = (T*)(start_p); \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	1972 T* end = p + (count); \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	1973 if (p < l) p = l; \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	1974 if (end > h) end = h; \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	1975 while (p < end) { \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	1976 (assert_fn)(p); \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	1977 do_oop; \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	1978 ++p; \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	1979 } \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	1980 }
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	1981
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 // 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	1984 // 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	1985 // flag.
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	1986 #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	1987 { \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	1988 /* 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	1989 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	1990 OopMapBlock* map = start_of_nonstatic_oop_maps(); \
938 b37c246bf7ce 6861660: OopMapBlock count/size confusion jcoomes parents: 876 diff changeset	1991 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	1992 if (UseCompressedOops) { \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	1993 while (map < end_map) { \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	1994 InstanceKlass_SPECIALIZED_OOP_ITERATE(narrowOop, \
938 b37c246bf7ce 6861660: OopMapBlock count/size confusion jcoomes parents: 876 diff changeset	1995 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	1996 do_oop, assert_fn) \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	1997 ++map; \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	1998 } \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	1999 } else { \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	2000 while (map < end_map) { \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	2001 InstanceKlass_SPECIALIZED_OOP_ITERATE(oop, \
938 b37c246bf7ce 6861660: OopMapBlock count/size confusion jcoomes parents: 876 diff changeset	2002 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	2003 do_oop, assert_fn) \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	2004 ++map; \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	2005 } \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	2006 } \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	2007 }
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	2008
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	2009 #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	2010 { \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	2011 OopMapBlock* const start_map = start_of_nonstatic_oop_maps(); \
938 b37c246bf7ce 6861660: OopMapBlock count/size confusion jcoomes parents: 876 diff changeset	2012 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	2013 if (UseCompressedOops) { \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	2014 while (start_map < map) { \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	2015 --map; \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	2016 InstanceKlass_SPECIALIZED_OOP_REVERSE_ITERATE(narrowOop, \
938 b37c246bf7ce 6861660: OopMapBlock count/size confusion jcoomes parents: 876 diff changeset	2017 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	2018 do_oop, assert_fn) \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	2019 } \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	2020 } else { \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	2021 while (start_map < map) { \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	2022 --map; \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	2023 InstanceKlass_SPECIALIZED_OOP_REVERSE_ITERATE(oop, \
938 b37c246bf7ce 6861660: OopMapBlock count/size confusion jcoomes parents: 876 diff changeset	2024 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	2025 do_oop, assert_fn) \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	2026 } \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	2027 } \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	2028 }
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	2029
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	2030 #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	2031 assert_fn) \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	2032 { \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	2033 /* 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	2034 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	2035 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	2036 all the maps. */ \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	2037 OopMapBlock* map = start_of_nonstatic_oop_maps(); \
938 b37c246bf7ce 6861660: OopMapBlock count/size confusion jcoomes parents: 876 diff changeset	2038 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	2039 if (UseCompressedOops) { \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	2040 while (map < end_map) { \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	2041 InstanceKlass_SPECIALIZED_BOUNDED_OOP_ITERATE(narrowOop, \
938 b37c246bf7ce 6861660: OopMapBlock count/size confusion jcoomes parents: 876 diff changeset	2042 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	2043 low, high, \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	2044 do_oop, assert_fn) \
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 } \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	2047 } else { \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	2048 while (map < end_map) { \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	2049 InstanceKlass_SPECIALIZED_BOUNDED_OOP_ITERATE(oop, \
938 b37c246bf7ce 6861660: OopMapBlock count/size confusion jcoomes parents: 876 diff changeset	2050 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	2051 low, high, \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	2052 do_oop, assert_fn) \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	2053 ++map; \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	2054 } \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	2055 } \
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
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2058 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	2059 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	2060 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	2061 InstanceKlass_OOP_MAP_ITERATE( \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	2062 obj, \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	2063 MarkSweep::mark_and_push(p), \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	2064 assert_is_in_closed_subset)
0 a61af66fc99e Initial load duke parents: diff changeset	2065 }
a61af66fc99e Initial load duke parents: diff changeset	2066
8001 db9981fd3124 8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS jprovino parents: 7610 diff changeset	2067 #if INCLUDE_ALL_GCS
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2068 void InstanceKlass::oop_follow_contents(ParCompactionManager* cm,
0 a61af66fc99e Initial load duke parents: diff changeset	2069 oop obj) {
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	2070 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	2071 PSParallelCompact::follow_klass(cm, obj->klass());
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2072 // 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	2073 // everything else.
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	2074 InstanceKlass_OOP_MAP_ITERATE( \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	2075 obj, \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	2076 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	2077 assert_is_in)
0 a61af66fc99e Initial load duke parents: diff changeset	2078 }
8001 db9981fd3124 8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS jprovino parents: 7610 diff changeset	2079 #endif // INCLUDE_ALL_GCS
0 a61af66fc99e Initial load duke parents: diff changeset	2080
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2081 // closure's do_metadata() method dictates whether the given closure should be
0 a61af66fc99e Initial load duke parents: diff changeset	2082 // applied to the klass ptr in the object header.
a61af66fc99e Initial load duke parents: diff changeset	2083
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2084 #define if_do_metadata_checked(closure, nv_suffix) \
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2085 /* 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	2086 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	2087 "Inconsistency in do_metadata"); \
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2088 if (closure->do_metadata##nv_suffix())
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2089
342 37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	2090 #define InstanceKlass_OOP_OOP_ITERATE_DEFN(OopClosureType, nv_suffix) \
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	2091 \
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2092 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	2093 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	2094 /* header */ \
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2095 if_do_metadata_checked(closure, nv_suffix) { \
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2096 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	2097 } \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	2098 InstanceKlass_OOP_MAP_ITERATE( \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	2099 obj, \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	2100 SpecializationStats:: \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	2101 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	2102 (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	2103 assert_is_in_closed_subset) \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	2104 return size_helper(); \
0 a61af66fc99e Initial load duke parents: diff changeset	2105 }
a61af66fc99e Initial load duke parents: diff changeset	2106
8001 db9981fd3124 8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS jprovino parents: 7610 diff changeset	2107 #if INCLUDE_ALL_GCS
342 37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	2108 #define InstanceKlass_OOP_OOP_ITERATE_BACKWARDS_DEFN(OopClosureType, nv_suffix) \
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	2109 \
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2110 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	2111 OopClosureType* closure) { \
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	2112 SpecializationStats::record_iterate_call##nv_suffix(SpecializationStats::ik); \
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	2113 /* header */ \
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2114 if_do_metadata_checked(closure, nv_suffix) { \
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2115 closure->do_klass##nv_suffix(obj->klass()); \
342 37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	2116 } \
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	2117 /* instance variables */ \
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	2118 InstanceKlass_OOP_MAP_REVERSE_ITERATE( \
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	2119 obj, \
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	2120 SpecializationStats::record_do_oop_call##nv_suffix(SpecializationStats::ik);\
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	2121 (closure)->do_oop##nv_suffix(p), \
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	2122 assert_is_in_closed_subset) \
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	2123 return size_helper(); \
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	2124 }
8001 db9981fd3124 8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS jprovino parents: 7610 diff changeset	2125 #endif // INCLUDE_ALL_GCS
342 37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	2126
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	2127 #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	2128 \
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2129 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	2130 OopClosureType* closure, \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	2131 MemRegion mr) { \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	2132 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	2133 if_do_metadata_checked(closure, nv_suffix) { \
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2134 if (mr.contains(obj)) { \
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2135 closure->do_klass##nv_suffix(obj->klass()); \
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2136 } \
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	2137 } \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	2138 InstanceKlass_BOUNDED_OOP_MAP_ITERATE( \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	2139 obj, mr.start(), mr.end(), \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	2140 (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	2141 assert_is_in_closed_subset) \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	2142 return size_helper(); \
0 a61af66fc99e Initial load duke parents: diff changeset	2143 }
a61af66fc99e Initial load duke parents: diff changeset	2144
a61af66fc99e Initial load duke parents: diff changeset	2145 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	2146 ALL_OOP_OOP_ITERATE_CLOSURES_2(InstanceKlass_OOP_OOP_ITERATE_DEFN)
0 a61af66fc99e Initial load duke parents: diff changeset	2147 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	2148 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	2149 #if INCLUDE_ALL_GCS
342 37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	2150 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	2151 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	2152 #endif // INCLUDE_ALL_GCS
0 a61af66fc99e Initial load duke parents: diff changeset	2153
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2154 int InstanceKlass::oop_adjust_pointers(oop obj) {
0 a61af66fc99e Initial load duke parents: diff changeset	2155 int size = size_helper();
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	2156 InstanceKlass_OOP_MAP_ITERATE( \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	2157 obj, \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	2158 MarkSweep::adjust_pointer(p), \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	2159 assert_is_in)
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2160 MarkSweep::adjust_klass(obj->klass());
0 a61af66fc99e Initial load duke parents: diff changeset	2161 return size;
a61af66fc99e Initial load duke parents: diff changeset	2162 }
a61af66fc99e Initial load duke parents: diff changeset	2163
8001 db9981fd3124 8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS jprovino parents: 7610 diff changeset	2164 #if INCLUDE_ALL_GCS
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2165 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	2166 InstanceKlass_OOP_MAP_REVERSE_ITERATE( \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	2167 obj, \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	2168 if (PSScavenge::should_scavenge(p)) { \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	2169 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	2170 }, \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	2171 assert_nothing )
0 a61af66fc99e Initial load duke parents: diff changeset	2172 }
a61af66fc99e Initial load duke parents: diff changeset	2173
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2174 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	2175 int size = size_helper();
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	2176 InstanceKlass_OOP_MAP_ITERATE( \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	2177 obj, \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	2178 PSParallelCompact::adjust_pointer(p), \
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2179 assert_is_in)
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2180 obj->update_header(cm);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2181 return size;
0 a61af66fc99e Initial load duke parents: diff changeset	2182 }
a61af66fc99e Initial load duke parents: diff changeset	2183
8001 db9981fd3124 8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS jprovino parents: 7610 diff changeset	2184 #endif // INCLUDE_ALL_GCS
0 a61af66fc99e Initial load duke parents: diff changeset	2185
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2186 void InstanceKlass::clean_implementors_list(BoolObjectClosure* is_alive) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2187 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	2188 if (is_interface()) {
49036505ab5f 7154670: The instanceKlass _implementors[] and _nof_implementors are not needed for non-interface klass. jiangli parents: 5969 diff changeset	2189 if (ClassUnloading) {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2190 Klass* impl = implementor();
5998 49036505ab5f 7154670: The instanceKlass _implementors[] and _nof_implementors are not needed for non-interface klass. jiangli parents: 5969 diff changeset	2191 if (impl != NULL) {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2192 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	2193 // remove this guy
8693 872b3feace55 8008750: [partfait] Null pointer deference in hotspot/src/share/vm/oops/instanceKlass.hpp morris parents: 8031 diff changeset	2194 Klass** klass = adr_implementor();
872b3feace55 8008750: [partfait] Null pointer deference in hotspot/src/share/vm/oops/instanceKlass.hpp morris parents: 8031 diff changeset	2195 assert(klass != NULL, "null klass");
872b3feace55 8008750: [partfait] Null pointer deference in hotspot/src/share/vm/oops/instanceKlass.hpp morris parents: 8031 diff changeset	2196 if (klass != NULL) {
872b3feace55 8008750: [partfait] Null pointer deference in hotspot/src/share/vm/oops/instanceKlass.hpp morris parents: 8031 diff changeset	2197 *klass = NULL;
872b3feace55 8008750: [partfait] Null pointer deference in hotspot/src/share/vm/oops/instanceKlass.hpp morris parents: 8031 diff changeset	2198 }
5998 49036505ab5f 7154670: The instanceKlass _implementors[] and _nof_implementors are not needed for non-interface klass. jiangli parents: 5969 diff changeset	2199 }
0 a61af66fc99e Initial load duke parents: diff changeset	2200 }
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2201 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2202 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2203 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2204
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2205 void InstanceKlass::clean_method_data(BoolObjectClosure* is_alive) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2206 for (int m = 0; m < methods()->length(); m++) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2207 MethodData* mdo = methods()->at(m)->method_data();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2208 if (mdo != NULL) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2209 for (ProfileData* data = mdo->first_data();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2210 mdo->is_valid(data);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2211 data = mdo->next_data(data)) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2212 data->clean_weak_klass_links(is_alive);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2213 }
13080 6e1826d5c23e 8027572: assert(r != 0) failed: invalid roland parents: 12995 diff changeset	2214 ParametersTypeData* parameters = mdo->parameters_type_data();
6e1826d5c23e 8027572: assert(r != 0) failed: invalid roland parents: 12995 diff changeset	2215 if (parameters != NULL) {
6e1826d5c23e 8027572: assert(r != 0) failed: invalid roland parents: 12995 diff changeset	2216 parameters->clean_weak_klass_links(is_alive);
6e1826d5c23e 8027572: assert(r != 0) failed: invalid roland parents: 12995 diff changeset	2217 }
0 a61af66fc99e Initial load duke parents: diff changeset	2218 }
a61af66fc99e Initial load duke parents: diff changeset	2219 }
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2220 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2221
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2222
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2223 static void remove_unshareable_in_class(Klass* k) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2224 // remove klass's unshareable info
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2225 k->remove_unshareable_info();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2226 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2227
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2228 void InstanceKlass::remove_unshareable_info() {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2229 Klass::remove_unshareable_info();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2230 // Unlink the class
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2231 if (is_linked()) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2232 unlink_class();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2233 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2234 init_implementor();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2235
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2236 constants()->remove_unshareable_info();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2237
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2238 for (int i = 0; i < methods()->length(); i++) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2239 Method* m = methods()->at(i);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2240 m->remove_unshareable_info();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2241 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2242
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2243 // do array classes also.
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2244 array_klasses_do(remove_unshareable_in_class);
0 a61af66fc99e Initial load duke parents: diff changeset	2245 }
a61af66fc99e Initial load duke parents: diff changeset	2246
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2247 void restore_unshareable_in_class(Klass* k, TRAPS) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2248 k->restore_unshareable_info(CHECK);
0 a61af66fc99e Initial load duke parents: diff changeset	2249 }
a61af66fc99e Initial load duke parents: diff changeset	2250
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2251 void InstanceKlass::restore_unshareable_info(TRAPS) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2252 Klass::restore_unshareable_info(CHECK);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2253 instanceKlassHandle ik(THREAD, this);
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 Array<Method> methods = ik->methods();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2256 int num_methods = methods->length();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2257 for (int index2 = 0; index2 < num_methods; ++index2) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2258 methodHandle m(THREAD, methods->at(index2));
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2259 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	2260 // 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	2261 m->restore_vtable();
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2262 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2263 if (JvmtiExport::has_redefined_a_class()) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2264 // Reinitialize vtable because RedefineClasses may have changed some
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2265 // 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	2266 // 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	2267 // 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	2268 // 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	2269 ResourceMark rm(THREAD);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2270 ik->vtable()->initialize_vtable(false, CHECK);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2271 ik->itable()->initialize_itable(false, CHECK);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2272 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2273
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2274 // restore constant pool resolved references
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2275 ik->constants()->restore_unshareable_info(CHECK);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2276
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2277 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	2278 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2279
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2280 static void clear_all_breakpoints(Method* m) {
0 a61af66fc99e Initial load duke parents: diff changeset	2281 m->clear_all_breakpoints();
a61af66fc99e Initial load duke parents: diff changeset	2282 }
a61af66fc99e Initial load duke parents: diff changeset	2283
10149 d587a5c30bd8 8011803: release_C_heap_structures is never called for anonymous classes. coleenp parents: 10133 diff changeset	2284
d587a5c30bd8 8011803: release_C_heap_structures is never called for anonymous classes. coleenp parents: 10133 diff changeset	2285 void InstanceKlass::notify_unload_class(InstanceKlass* ik) {
d587a5c30bd8 8011803: release_C_heap_structures is never called for anonymous classes. coleenp parents: 10133 diff changeset	2286 // notify the debugger
d587a5c30bd8 8011803: release_C_heap_structures is never called for anonymous classes. coleenp parents: 10133 diff changeset	2287 if (JvmtiExport::should_post_class_unload()) {
d587a5c30bd8 8011803: release_C_heap_structures is never called for anonymous classes. coleenp parents: 10133 diff changeset	2288 JvmtiExport::post_class_unload(ik);
d587a5c30bd8 8011803: release_C_heap_structures is never called for anonymous classes. coleenp parents: 10133 diff changeset	2289 }
d587a5c30bd8 8011803: release_C_heap_structures is never called for anonymous classes. coleenp parents: 10133 diff changeset	2290
d587a5c30bd8 8011803: release_C_heap_structures is never called for anonymous classes. coleenp parents: 10133 diff changeset	2291 // notify ClassLoadingService of class unload
d587a5c30bd8 8011803: release_C_heap_structures is never called for anonymous classes. coleenp parents: 10133 diff changeset	2292 ClassLoadingService::notify_class_unloaded(ik);
d587a5c30bd8 8011803: release_C_heap_structures is never called for anonymous classes. coleenp parents: 10133 diff changeset	2293 }
d587a5c30bd8 8011803: release_C_heap_structures is never called for anonymous classes. coleenp parents: 10133 diff changeset	2294
d587a5c30bd8 8011803: release_C_heap_structures is never called for anonymous classes. coleenp parents: 10133 diff changeset	2295 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	2296 // Clean up C heap
d587a5c30bd8 8011803: release_C_heap_structures is never called for anonymous classes. coleenp parents: 10133 diff changeset	2297 ik->release_C_heap_structures();
d587a5c30bd8 8011803: release_C_heap_structures is never called for anonymous classes. coleenp parents: 10133 diff changeset	2298 ik->constants()->release_C_heap_structures();
d587a5c30bd8 8011803: release_C_heap_structures is never called for anonymous classes. coleenp parents: 10133 diff changeset	2299 }
d587a5c30bd8 8011803: release_C_heap_structures is never called for anonymous classes. coleenp parents: 10133 diff changeset	2300
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2301 void InstanceKlass::release_C_heap_structures() {
10149 d587a5c30bd8 8011803: release_C_heap_structures is never called for anonymous classes. coleenp parents: 10133 diff changeset	2302
d587a5c30bd8 8011803: release_C_heap_structures is never called for anonymous classes. coleenp parents: 10133 diff changeset	2303 // 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	2304 // 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	2305 // redefine classes.
d587a5c30bd8 8011803: release_C_heap_structures is never called for anonymous classes. coleenp parents: 10133 diff changeset	2306
0 a61af66fc99e Initial load duke parents: diff changeset	2307 // Deallocate oop map cache
a61af66fc99e Initial load duke parents: diff changeset	2308 if (_oop_map_cache != NULL) {
a61af66fc99e Initial load duke parents: diff changeset	2309 delete _oop_map_cache;
a61af66fc99e Initial load duke parents: diff changeset	2310 _oop_map_cache = NULL;
a61af66fc99e Initial load duke parents: diff changeset	2311 }
a61af66fc99e Initial load duke parents: diff changeset	2312
a61af66fc99e Initial load duke parents: diff changeset	2313 // Deallocate JNI identifiers for jfieldIDs
a61af66fc99e Initial load duke parents: diff changeset	2314 JNIid::deallocate(jni_ids());
a61af66fc99e Initial load duke parents: diff changeset	2315 set_jni_ids(NULL);
a61af66fc99e Initial load duke parents: diff changeset	2316
a61af66fc99e Initial load duke parents: diff changeset	2317 jmethodID* jmeths = methods_jmethod_ids_acquire();
a61af66fc99e Initial load duke parents: diff changeset	2318 if (jmeths != (jmethodID*)NULL) {
a61af66fc99e Initial load duke parents: diff changeset	2319 release_set_methods_jmethod_ids(NULL);
a61af66fc99e Initial load duke parents: diff changeset	2320 FreeHeap(jmeths);
a61af66fc99e Initial load duke parents: diff changeset	2321 }
a61af66fc99e Initial load duke parents: diff changeset	2322
10347 6c138b9851fb 8013945: CMS fatal error: must own lock MemberNameTable_lock sspitsyn parents: 10345 diff changeset	2323 // Deallocate MemberNameTable
6c138b9851fb 8013945: CMS fatal error: must own lock MemberNameTable_lock sspitsyn parents: 10345 diff changeset	2324 {
6c138b9851fb 8013945: CMS fatal error: must own lock MemberNameTable_lock sspitsyn parents: 10345 diff changeset	2325 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	2326 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	2327 MemberNameTable* mnt = member_names();
6c138b9851fb 8013945: CMS fatal error: must own lock MemberNameTable_lock sspitsyn parents: 10345 diff changeset	2328 if (mnt != NULL) {
6c138b9851fb 8013945: CMS fatal error: must own lock MemberNameTable_lock sspitsyn parents: 10345 diff changeset	2329 delete mnt;
6c138b9851fb 8013945: CMS fatal error: must own lock MemberNameTable_lock sspitsyn parents: 10345 diff changeset	2330 set_member_names(NULL);
6c138b9851fb 8013945: CMS fatal error: must own lock MemberNameTable_lock sspitsyn parents: 10345 diff changeset	2331 }
10133 6337ca4dcad8 8008511: JSR 292: MemberName vmtarget refs to methods must be updated at class redefinition sspitsyn parents: 9062 diff changeset	2332 }
6337ca4dcad8 8008511: JSR 292: MemberName vmtarget refs to methods must be updated at class redefinition sspitsyn parents: 9062 diff changeset	2333
0 a61af66fc99e Initial load duke parents: diff changeset	2334 // release dependencies
a61af66fc99e Initial load duke parents: diff changeset	2335 nmethodBucket* b = _dependencies;
a61af66fc99e Initial load duke parents: diff changeset	2336 _dependencies = NULL;
a61af66fc99e Initial load duke parents: diff changeset	2337 while (b != NULL) {
a61af66fc99e Initial load duke parents: diff changeset	2338 nmethodBucket* next = b->next();
a61af66fc99e Initial load duke parents: diff changeset	2339 delete b;
a61af66fc99e Initial load duke parents: diff changeset	2340 b = next;
a61af66fc99e Initial load duke parents: diff changeset	2341 }
a61af66fc99e Initial load duke parents: diff changeset	2342
a61af66fc99e Initial load duke parents: diff changeset	2343 // Deallocate breakpoint records
a61af66fc99e Initial load duke parents: diff changeset	2344 if (breakpoints() != 0x0) {
a61af66fc99e Initial load duke parents: diff changeset	2345 methods_do(clear_all_breakpoints);
a61af66fc99e Initial load duke parents: diff changeset	2346 assert(breakpoints() == 0x0, "should have cleared breakpoints");
a61af66fc99e Initial load duke parents: diff changeset	2347 }
a61af66fc99e Initial load duke parents: diff changeset	2348
a61af66fc99e Initial load duke parents: diff changeset	2349 // deallocate information about previous versions
a61af66fc99e Initial load duke parents: diff changeset	2350 if (_previous_versions != NULL) {
a61af66fc99e Initial load duke parents: diff changeset	2351 for (int i = _previous_versions->length() - 1; i >= 0; i--) {
a61af66fc99e Initial load duke parents: diff changeset	2352 PreviousVersionNode * pv_node = _previous_versions->at(i);
a61af66fc99e Initial load duke parents: diff changeset	2353 delete pv_node;
a61af66fc99e Initial load duke parents: diff changeset	2354 }
a61af66fc99e Initial load duke parents: diff changeset	2355 delete _previous_versions;
a61af66fc99e Initial load duke parents: diff changeset	2356 _previous_versions = NULL;
a61af66fc99e Initial load duke parents: diff changeset	2357 }
a61af66fc99e Initial load duke parents: diff changeset	2358
a61af66fc99e Initial load duke parents: diff changeset	2359 // deallocate the cached class file
11148 825e6cb66923 8020309: Eliminate InstanceKlass::_cached_class_file_len. jiangli parents: 11096 diff changeset	2360 if (_cached_class_file != NULL) {
825e6cb66923 8020309: Eliminate InstanceKlass::_cached_class_file_len. jiangli parents: 11096 diff changeset	2361 os::free(_cached_class_file, mtClass);
825e6cb66923 8020309: Eliminate InstanceKlass::_cached_class_file_len. jiangli parents: 11096 diff changeset	2362 _cached_class_file = NULL;
0 a61af66fc99e Initial load duke parents: diff changeset	2363 }
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	2364
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	2365 // 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	2366 if (_name != NULL) _name->decrement_refcount();
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	2367 // 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	2368 // class can't be referenced anymore).
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	2369 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	2370 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	2371
ecd24264898b 8005048: NMT: #loaded classes needs to just show the # defined classes zgu parents: 7180 diff changeset	2372 assert(_total_instanceKlass_count >= 1, "Sanity check");
ecd24264898b 8005048: NMT: #loaded classes needs to just show the # defined classes zgu parents: 7180 diff changeset	2373 Atomic::dec(&_total_instanceKlass_count);
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	2374 }
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	2375
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2376 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	2377 if (array == NULL) {
04ade88d9712 6294277: java -Xdebug crashes on SourceDebugExtension attribute larger than 64K fparain parents: 6197 diff changeset	2378 _source_debug_extension = NULL;
04ade88d9712 6294277: java -Xdebug crashes on SourceDebugExtension attribute larger than 64K fparain parents: 6197 diff changeset	2379 } else {
04ade88d9712 6294277: java -Xdebug crashes on SourceDebugExtension attribute larger than 64K fparain parents: 6197 diff changeset	2380 // 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	2381 // 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	2382 // 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	2383 // unlikely to happen.
04ade88d9712 6294277: java -Xdebug crashes on SourceDebugExtension attribute larger than 64K fparain parents: 6197 diff changeset	2384 assert((length+1) > length, "Overflow checking");
04ade88d9712 6294277: java -Xdebug crashes on SourceDebugExtension attribute larger than 64K fparain parents: 6197 diff changeset	2385 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	2386 for (int i = 0; i < length; i++) {
04ade88d9712 6294277: java -Xdebug crashes on SourceDebugExtension attribute larger than 64K fparain parents: 6197 diff changeset	2387 sde[i] = array[i];
04ade88d9712 6294277: java -Xdebug crashes on SourceDebugExtension attribute larger than 64K fparain parents: 6197 diff changeset	2388 }
04ade88d9712 6294277: java -Xdebug crashes on SourceDebugExtension attribute larger than 64K fparain parents: 6197 diff changeset	2389 sde[length] = '\0';
04ade88d9712 6294277: java -Xdebug crashes on SourceDebugExtension attribute larger than 64K fparain parents: 6197 diff changeset	2390 _source_debug_extension = sde;
04ade88d9712 6294277: java -Xdebug crashes on SourceDebugExtension attribute larger than 64K fparain parents: 6197 diff changeset	2391 }
0 a61af66fc99e Initial load duke parents: diff changeset	2392 }
a61af66fc99e Initial load duke parents: diff changeset	2393
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2394 address InstanceKlass::static_field_addr(int offset) {
12316 190899198332 7195622: CheckUnhandledOops has limited usefulness now hseigel parents: 12287 diff changeset	2395 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	2396 }
c7f3d0b4570f 7017732: move static fields into Class to prepare for perm gen removal never parents: 2357 diff changeset	2397
c7f3d0b4570f 7017732: move static fields into Class to prepare for perm gen removal never parents: 2357 diff changeset	2398
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2399 const char* InstanceKlass::signature_name() const {
12995 e64f1fe9756b 8024423: JVMTI: GetLoadedClasses doesn't enumerate anonymous classes farvidsson parents: 12946 diff changeset	2400 int hash_len = 0;
e64f1fe9756b 8024423: JVMTI: GetLoadedClasses doesn't enumerate anonymous classes farvidsson parents: 12946 diff changeset	2401 char hash_buf[40];
e64f1fe9756b 8024423: JVMTI: GetLoadedClasses doesn't enumerate anonymous classes farvidsson parents: 12946 diff changeset	2402
e64f1fe9756b 8024423: JVMTI: GetLoadedClasses doesn't enumerate anonymous classes farvidsson parents: 12946 diff changeset	2403 // 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	2404 if (is_anonymous()) {
e64f1fe9756b 8024423: JVMTI: GetLoadedClasses doesn't enumerate anonymous classes farvidsson parents: 12946 diff changeset	2405 assert(EnableInvokeDynamic, "EnableInvokeDynamic was not set.");
e64f1fe9756b 8024423: JVMTI: GetLoadedClasses doesn't enumerate anonymous classes farvidsson parents: 12946 diff changeset	2406 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	2407 sprintf(hash_buf, "/" UINTX_FORMAT, (uintx)hash);
e64f1fe9756b 8024423: JVMTI: GetLoadedClasses doesn't enumerate anonymous classes farvidsson parents: 12946 diff changeset	2408 hash_len = (int)strlen(hash_buf);
e64f1fe9756b 8024423: JVMTI: GetLoadedClasses doesn't enumerate anonymous classes farvidsson parents: 12946 diff changeset	2409 }
e64f1fe9756b 8024423: JVMTI: GetLoadedClasses doesn't enumerate anonymous classes farvidsson parents: 12946 diff changeset	2410
e64f1fe9756b 8024423: JVMTI: GetLoadedClasses doesn't enumerate anonymous classes farvidsson parents: 12946 diff changeset	2411 // Get the internal name as a c string
0 a61af66fc99e Initial load duke parents: diff changeset	2412 const char* src = (const char*) (name()->as_C_string());
a61af66fc99e Initial load duke parents: diff changeset	2413 const int src_length = (int)strlen(src);
12995 e64f1fe9756b 8024423: JVMTI: GetLoadedClasses doesn't enumerate anonymous classes farvidsson parents: 12946 diff changeset	2414
e64f1fe9756b 8024423: JVMTI: GetLoadedClasses doesn't enumerate anonymous classes farvidsson parents: 12946 diff changeset	2415 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	2416
e64f1fe9756b 8024423: JVMTI: GetLoadedClasses doesn't enumerate anonymous classes farvidsson parents: 12946 diff changeset	2417 // Add L as type indicator
0 a61af66fc99e Initial load duke parents: diff changeset	2418 int dest_index = 0;
a61af66fc99e Initial load duke parents: diff changeset	2419 dest[dest_index++] = 'L';
12995 e64f1fe9756b 8024423: JVMTI: GetLoadedClasses doesn't enumerate anonymous classes farvidsson parents: 12946 diff changeset	2420
e64f1fe9756b 8024423: JVMTI: GetLoadedClasses doesn't enumerate anonymous classes farvidsson parents: 12946 diff changeset	2421 // Add the actual class name
e64f1fe9756b 8024423: JVMTI: GetLoadedClasses doesn't enumerate anonymous classes farvidsson parents: 12946 diff changeset	2422 for (int src_index = 0; src_index < src_length; ) {
0 a61af66fc99e Initial load duke parents: diff changeset	2423 dest[dest_index++] = src[src_index++];
a61af66fc99e Initial load duke parents: diff changeset	2424 }
12995 e64f1fe9756b 8024423: JVMTI: GetLoadedClasses doesn't enumerate anonymous classes farvidsson parents: 12946 diff changeset	2425
e64f1fe9756b 8024423: JVMTI: GetLoadedClasses doesn't enumerate anonymous classes farvidsson parents: 12946 diff changeset	2426 // If we have a hash, append it
e64f1fe9756b 8024423: JVMTI: GetLoadedClasses doesn't enumerate anonymous classes farvidsson parents: 12946 diff changeset	2427 for (int hash_index = 0; hash_index < hash_len; ) {
e64f1fe9756b 8024423: JVMTI: GetLoadedClasses doesn't enumerate anonymous classes farvidsson parents: 12946 diff changeset	2428 dest[dest_index++] = hash_buf[hash_index++];
e64f1fe9756b 8024423: JVMTI: GetLoadedClasses doesn't enumerate anonymous classes farvidsson parents: 12946 diff changeset	2429 }
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 // Add the semicolon and the NULL
0 a61af66fc99e Initial load duke parents: diff changeset	2432 dest[dest_index++] = ';';
a61af66fc99e Initial load duke parents: diff changeset	2433 dest[dest_index] = '\0';
a61af66fc99e Initial load duke parents: diff changeset	2434 return dest;
a61af66fc99e Initial load duke parents: diff changeset	2435 }
a61af66fc99e Initial load duke parents: diff changeset	2436
a61af66fc99e Initial load duke parents: diff changeset	2437 // different verisons of is_same_class_package
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2438 bool InstanceKlass::is_same_class_package(Klass* class2) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2439 Klass* class1 = this;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2440 oop classloader1 = InstanceKlass::cast(class1)->class_loader();
6983 070d523b96a7 8001471: Klass::cast() does nothing hseigel parents: 6934 diff changeset	2441 Symbol* classname1 = class1->name();
070d523b96a7 8001471: Klass::cast() does nothing hseigel parents: 6934 diff changeset	2442
070d523b96a7 8001471: Klass::cast() does nothing hseigel parents: 6934 diff changeset	2443 if (class2->oop_is_objArray()) {
6831 d8ce2825b193 8000213: NPG: Should have renamed arrayKlass and typeArrayKlass coleenp parents: 6735 diff changeset	2444 class2 = ObjArrayKlass::cast(class2)->bottom_klass();
0 a61af66fc99e Initial load duke parents: diff changeset	2445 }
a61af66fc99e Initial load duke parents: diff changeset	2446 oop classloader2;
6983 070d523b96a7 8001471: Klass::cast() does nothing hseigel parents: 6934 diff changeset	2447 if (class2->oop_is_instance()) {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2448 classloader2 = InstanceKlass::cast(class2)->class_loader();
0 a61af66fc99e Initial load duke parents: diff changeset	2449 } else {
6983 070d523b96a7 8001471: Klass::cast() does nothing hseigel parents: 6934 diff changeset	2450 assert(class2->oop_is_typeArray(), "should be type array");
0 a61af66fc99e Initial load duke parents: diff changeset	2451 classloader2 = NULL;
a61af66fc99e Initial load duke parents: diff changeset	2452 }
6983 070d523b96a7 8001471: Klass::cast() does nothing hseigel parents: 6934 diff changeset	2453 Symbol* classname2 = class2->name();
0 a61af66fc99e Initial load duke parents: diff changeset	2454
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2455 return InstanceKlass::is_same_class_package(classloader1, classname1,
0 a61af66fc99e Initial load duke parents: diff changeset	2456 classloader2, classname2);
a61af66fc99e Initial load duke parents: diff changeset	2457 }
a61af66fc99e Initial load duke parents: diff changeset	2458
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2459 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	2460 Klass* class1 = this;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2461 oop classloader1 = InstanceKlass::cast(class1)->class_loader();
6983 070d523b96a7 8001471: Klass::cast() does nothing hseigel parents: 6934 diff changeset	2462 Symbol* classname1 = class1->name();
0 a61af66fc99e Initial load duke parents: diff changeset	2463
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2464 return InstanceKlass::is_same_class_package(classloader1, classname1,
0 a61af66fc99e Initial load duke parents: diff changeset	2465 classloader2, classname2);
a61af66fc99e Initial load duke parents: diff changeset	2466 }
a61af66fc99e Initial load duke parents: diff changeset	2467
a61af66fc99e Initial load duke parents: diff changeset	2468 // return true if two classes are in the same package, classloader
a61af66fc99e Initial load duke parents: diff changeset	2469 // 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	2470 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	2471 oop class_loader2, Symbol* class_name2) {
0 a61af66fc99e Initial load duke parents: diff changeset	2472 if (class_loader1 != class_loader2) {
a61af66fc99e Initial load duke parents: diff changeset	2473 return false;
665 c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 605 diff changeset	2474 } else if (class_name1 == class_name2) {
c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 605 diff changeset	2475 return true; // skip painful bytewise comparison
0 a61af66fc99e Initial load duke parents: diff changeset	2476 } else {
a61af66fc99e Initial load duke parents: diff changeset	2477 ResourceMark rm;
a61af66fc99e Initial load duke parents: diff changeset	2478
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	2479 // The Symbol*'s are in UTF8 encoding. Since we only need to check explicitly
0 a61af66fc99e Initial load duke parents: diff changeset	2480 // for ASCII characters ('/', 'L', '['), we can keep them in UTF8 encoding.
a61af66fc99e Initial load duke parents: diff changeset	2481 // 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	2482 const jbyte *name1 = class_name1->base();
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	2483 const jbyte *name2 = class_name2->base();
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	2484
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	2485 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	2486 const jbyte *last_slash2 = UTF8::strrchr(name2, class_name2->utf8_length(), '/');
0 a61af66fc99e Initial load duke parents: diff changeset	2487
a61af66fc99e Initial load duke parents: diff changeset	2488 if ((last_slash1 == NULL) \|\| (last_slash2 == NULL)) {
a61af66fc99e Initial load duke parents: diff changeset	2489 // One of the two doesn't have a package. Only return true
a61af66fc99e Initial load duke parents: diff changeset	2490 // if the other one also doesn't have a package.
a61af66fc99e Initial load duke parents: diff changeset	2491 return last_slash1 == last_slash2;
a61af66fc99e Initial load duke parents: diff changeset	2492 } else {
a61af66fc99e Initial load duke parents: diff changeset	2493 // Skip over '['s
a61af66fc99e Initial load duke parents: diff changeset	2494 if (*name1 == '[') {
a61af66fc99e Initial load duke parents: diff changeset	2495 do {
a61af66fc99e Initial load duke parents: diff changeset	2496 name1++;
a61af66fc99e Initial load duke parents: diff changeset	2497 } while (*name1 == '[');
a61af66fc99e Initial load duke parents: diff changeset	2498 if (*name1 != 'L') {
a61af66fc99e Initial load duke parents: diff changeset	2499 // Something is terribly wrong. Shouldn't be here.
a61af66fc99e Initial load duke parents: diff changeset	2500 return false;
a61af66fc99e Initial load duke parents: diff changeset	2501 }
a61af66fc99e Initial load duke parents: diff changeset	2502 }
a61af66fc99e Initial load duke parents: diff changeset	2503 if (*name2 == '[') {
a61af66fc99e Initial load duke parents: diff changeset	2504 do {
a61af66fc99e Initial load duke parents: diff changeset	2505 name2++;
a61af66fc99e Initial load duke parents: diff changeset	2506 } while (*name2 == '[');
a61af66fc99e Initial load duke parents: diff changeset	2507 if (*name2 != 'L') {
a61af66fc99e Initial load duke parents: diff changeset	2508 // Something is terribly wrong. Shouldn't be here.
a61af66fc99e Initial load duke parents: diff changeset	2509 return false;
a61af66fc99e Initial load duke parents: diff changeset	2510 }
a61af66fc99e Initial load duke parents: diff changeset	2511 }
a61af66fc99e Initial load duke parents: diff changeset	2512
a61af66fc99e Initial load duke parents: diff changeset	2513 // Check that package part is identical
a61af66fc99e Initial load duke parents: diff changeset	2514 int length1 = last_slash1 - name1;
a61af66fc99e Initial load duke parents: diff changeset	2515 int length2 = last_slash2 - name2;
a61af66fc99e Initial load duke parents: diff changeset	2516
a61af66fc99e Initial load duke parents: diff changeset	2517 return UTF8::equal(name1, length1, name2, length2);
a61af66fc99e Initial load duke parents: diff changeset	2518 }
a61af66fc99e Initial load duke parents: diff changeset	2519 }
a61af66fc99e Initial load duke parents: diff changeset	2520 }
a61af66fc99e Initial load duke parents: diff changeset	2521
652 4aaa9f5e02a8 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242. acorn parents: 605 diff changeset	2522 // 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	2523 // See JSL 3rd edition 8.4.6.1
4aaa9f5e02a8 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242. acorn parents: 605 diff changeset	2524 // Assumes name-signature match
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2525 // "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	2526 // 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	2527 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	2528 // Private methods can not be overridden
4aaa9f5e02a8 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242. acorn parents: 605 diff changeset	2529 if (super_method->is_private()) {
4aaa9f5e02a8 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242. acorn parents: 605 diff changeset	2530 return false;
4aaa9f5e02a8 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242. acorn parents: 605 diff changeset	2531 }
4aaa9f5e02a8 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242. acorn parents: 605 diff changeset	2532 // If super method is accessible, then override
4aaa9f5e02a8 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242. acorn parents: 605 diff changeset	2533 if ((super_method->is_protected()) \|\|
4aaa9f5e02a8 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242. acorn parents: 605 diff changeset	2534 (super_method->is_public())) {
4aaa9f5e02a8 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242. acorn parents: 605 diff changeset	2535 return true;
4aaa9f5e02a8 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242. acorn parents: 605 diff changeset	2536 }
4aaa9f5e02a8 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242. acorn parents: 605 diff changeset	2537 // Package-private methods are not inherited outside of package
4aaa9f5e02a8 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242. acorn parents: 605 diff changeset	2538 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	2539 return(is_same_class_package(targetclassloader(), targetclassname));
652 4aaa9f5e02a8 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242. acorn parents: 605 diff changeset	2540 }
0 a61af66fc99e Initial load duke parents: diff changeset	2541
665 c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 605 diff changeset	2542 /* 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	2543 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	2544 Symbol*& simple_name_result, TRAPS) {
665 c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 605 diff changeset	2545 ...
c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 605 diff changeset	2546 }
c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 605 diff changeset	2547 */
c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 605 diff changeset	2548
c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 605 diff changeset	2549 // 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	2550 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	2551 Klass* class2_oop, TRAPS) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2552 if (class2_oop == class1()) return true;
6983 070d523b96a7 8001471: Klass::cast() does nothing hseigel parents: 6934 diff changeset	2553 if (!class2_oop->oop_is_instance()) return false;
665 c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 605 diff changeset	2554 instanceKlassHandle class2(THREAD, class2_oop);
c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 605 diff changeset	2555
c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 605 diff changeset	2556 // must be in same package before we try anything else
c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 605 diff changeset	2557 if (!class1->is_same_class_package(class2->class_loader(), class2->name()))
c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 605 diff changeset	2558 return false;
c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 605 diff changeset	2559
c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 605 diff changeset	2560 // As long as there is an outer1.getEnclosingClass,
c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 605 diff changeset	2561 // shift the search outward.
c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 605 diff changeset	2562 instanceKlassHandle outer1 = class1;
c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 605 diff changeset	2563 for (;;) {
c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 605 diff changeset	2564 // As we walk along, look for equalities between outer1 and class2.
c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 605 diff changeset	2565 // Eventually, the walks will terminate as outer1 stops
c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 605 diff changeset	2566 // 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	2567 bool ignore_inner_is_member;
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2568 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	2569 CHECK_false);
665 c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 605 diff changeset	2570 if (next == NULL) break;
c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 605 diff changeset	2571 if (next == class2()) return true;
c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 605 diff changeset	2572 outer1 = instanceKlassHandle(THREAD, next);
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 // Now do the same for class2.
c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 605 diff changeset	2576 instanceKlassHandle outer2 = class2;
c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 605 diff changeset	2577 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	2578 bool ignore_inner_is_member;
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2579 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	2580 CHECK_false);
665 c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 605 diff changeset	2581 if (next == NULL) break;
c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 605 diff changeset	2582 // Might as well check the new outer against all available values.
c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 605 diff changeset	2583 if (next == class1()) return true;
c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 605 diff changeset	2584 if (next == outer1()) return true;
c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 605 diff changeset	2585 outer2 = instanceKlassHandle(THREAD, next);
c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 605 diff changeset	2586 }
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 // 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	2589 // two classes, we know they are in separate package members.
c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 605 diff changeset	2590 return false;
c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 605 diff changeset	2591 }
c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 605 diff changeset	2592
0 a61af66fc99e Initial load duke parents: diff changeset	2593
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2594 jint InstanceKlass::compute_modifier_flags(TRAPS) const {
0 a61af66fc99e Initial load duke parents: diff changeset	2595 jint access = access_flags().as_int();
a61af66fc99e Initial load duke parents: diff changeset	2596
a61af66fc99e Initial load duke parents: diff changeset	2597 // 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	2598 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	2599 InnerClassesIterator iter(ik);
f7c4174b33ba 7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field. jiangli parents: 4739 diff changeset	2600 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	2601 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	2602 // 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	2603 // 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	2604 if (ioff == 0) continue;
f7c4174b33ba 7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field. jiangli parents: 4739 diff changeset	2605
f7c4174b33ba 7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field. jiangli parents: 4739 diff changeset	2606 // 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	2607 // 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	2608 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	2609 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	2610 // 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	2611 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	2612 break;
0 a61af66fc99e Initial load duke parents: diff changeset	2613 }
a61af66fc99e Initial load duke parents: diff changeset	2614 }
a61af66fc99e Initial load duke parents: diff changeset	2615 // Remember to strip ACC_SUPER bit
a61af66fc99e Initial load duke parents: diff changeset	2616 return (access & (~JVM_ACC_SUPER)) & JVM_ACC_WRITTEN_FLAGS;
a61af66fc99e Initial load duke parents: diff changeset	2617 }
a61af66fc99e Initial load duke parents: diff changeset	2618
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2619 jint InstanceKlass::jvmti_class_status() const {
0 a61af66fc99e Initial load duke parents: diff changeset	2620 jint result = 0;
a61af66fc99e Initial load duke parents: diff changeset	2621
a61af66fc99e Initial load duke parents: diff changeset	2622 if (is_linked()) {
a61af66fc99e Initial load duke parents: diff changeset	2623 result \|= JVMTI_CLASS_STATUS_VERIFIED \| JVMTI_CLASS_STATUS_PREPARED;
a61af66fc99e Initial load duke parents: diff changeset	2624 }
a61af66fc99e Initial load duke parents: diff changeset	2625
a61af66fc99e Initial load duke parents: diff changeset	2626 if (is_initialized()) {
a61af66fc99e Initial load duke parents: diff changeset	2627 assert(is_linked(), "Class status is not consistent");
a61af66fc99e Initial load duke parents: diff changeset	2628 result \|= JVMTI_CLASS_STATUS_INITIALIZED;
a61af66fc99e Initial load duke parents: diff changeset	2629 }
a61af66fc99e Initial load duke parents: diff changeset	2630 if (is_in_error_state()) {
a61af66fc99e Initial load duke parents: diff changeset	2631 result \|= JVMTI_CLASS_STATUS_ERROR;
a61af66fc99e Initial load duke parents: diff changeset	2632 }
a61af66fc99e Initial load duke parents: diff changeset	2633 return result;
a61af66fc99e Initial load duke parents: diff changeset	2634 }
a61af66fc99e Initial load duke parents: diff changeset	2635
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2636 Method* InstanceKlass::method_at_itable(Klass* holder, int index, TRAPS) {
0 a61af66fc99e Initial load duke parents: diff changeset	2637 itableOffsetEntry* ioe = (itableOffsetEntry*)start_of_itable();
a61af66fc99e Initial load duke parents: diff changeset	2638 int method_table_offset_in_words = ioe->offset()/wordSize;
a61af66fc99e Initial load duke parents: diff changeset	2639 int nof_interfaces = (method_table_offset_in_words - itable_offset_in_words())
a61af66fc99e Initial load duke parents: diff changeset	2640 / itableOffsetEntry::size();
a61af66fc99e Initial load duke parents: diff changeset	2641
a61af66fc99e Initial load duke parents: diff changeset	2642 for (int cnt = 0 ; ; cnt ++, ioe ++) {
605 98cb887364d3 6810672: Comment typos twisti parents: 356 diff changeset	2643 // If the interface isn't implemented by the receiver class,
0 a61af66fc99e Initial load duke parents: diff changeset	2644 // the VM should throw IncompatibleClassChangeError.
a61af66fc99e Initial load duke parents: diff changeset	2645 if (cnt >= nof_interfaces) {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2646 THROW_NULL(vmSymbols::java_lang_IncompatibleClassChangeError());
0 a61af66fc99e Initial load duke parents: diff changeset	2647 }
a61af66fc99e Initial load duke parents: diff changeset	2648
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2649 Klass* ik = ioe->interface_klass();
0 a61af66fc99e Initial load duke parents: diff changeset	2650 if (ik == holder) break;
a61af66fc99e Initial load duke parents: diff changeset	2651 }
a61af66fc99e Initial load duke parents: diff changeset	2652
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2653 itableMethodEntry* ime = ioe->first_method_entry(this);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2654 Method* m = ime[index].method();
0 a61af66fc99e Initial load duke parents: diff changeset	2655 if (m == NULL) {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2656 THROW_NULL(vmSymbols::java_lang_AbstractMethodError());
0 a61af66fc99e Initial load duke parents: diff changeset	2657 }
a61af66fc99e Initial load duke parents: diff changeset	2658 return m;
a61af66fc99e Initial load duke parents: diff changeset	2659 }
a61af66fc99e Initial load duke parents: diff changeset	2660
12823 ac9cb1d5a202 8009130: Lambda: Fix access controls, loader constraints. acorn parents: 12811 diff changeset	2661
ac9cb1d5a202 8009130: Lambda: Fix access controls, loader constraints. acorn parents: 12811 diff changeset	2662 #if INCLUDE_JVMTI
ac9cb1d5a202 8009130: Lambda: Fix access controls, loader constraints. acorn parents: 12811 diff changeset	2663 // update default_methods for redefineclasses for methods that are
ac9cb1d5a202 8009130: Lambda: Fix access controls, loader constraints. acorn parents: 12811 diff changeset	2664 // 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	2665 // redefinition
ac9cb1d5a202 8009130: Lambda: Fix access controls, loader constraints. acorn parents: 12811 diff changeset	2666 // 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	2667 void InstanceKlass::adjust_default_methods(Method old_methods, Method new_methods,
ac9cb1d5a202 8009130: Lambda: Fix access controls, loader constraints. acorn parents: 12811 diff changeset	2668 int methods_length, bool* trace_name_printed) {
ac9cb1d5a202 8009130: Lambda: Fix access controls, loader constraints. acorn parents: 12811 diff changeset	2669 // 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	2670 if (default_methods() != NULL) {
ac9cb1d5a202 8009130: Lambda: Fix access controls, loader constraints. acorn parents: 12811 diff changeset	2671 for (int j = 0; j < methods_length; j++) {
ac9cb1d5a202 8009130: Lambda: Fix access controls, loader constraints. acorn parents: 12811 diff changeset	2672 Method* old_method = old_methods[j];
ac9cb1d5a202 8009130: Lambda: Fix access controls, loader constraints. acorn parents: 12811 diff changeset	2673 Method* new_method = new_methods[j];
ac9cb1d5a202 8009130: Lambda: Fix access controls, loader constraints. acorn parents: 12811 diff changeset	2674
ac9cb1d5a202 8009130: Lambda: Fix access controls, loader constraints. acorn parents: 12811 diff changeset	2675 for (int index = 0; index < default_methods()->length(); index ++) {
ac9cb1d5a202 8009130: Lambda: Fix access controls, loader constraints. acorn parents: 12811 diff changeset	2676 if (default_methods()->at(index) == old_method) {
ac9cb1d5a202 8009130: Lambda: Fix access controls, loader constraints. acorn parents: 12811 diff changeset	2677 default_methods()->at_put(index, new_method);
ac9cb1d5a202 8009130: Lambda: Fix access controls, loader constraints. acorn parents: 12811 diff changeset	2678 if (RC_TRACE_IN_RANGE(0x00100000, 0x00400000)) {
ac9cb1d5a202 8009130: Lambda: Fix access controls, loader constraints. acorn parents: 12811 diff changeset	2679 if (!(*trace_name_printed)) {
ac9cb1d5a202 8009130: Lambda: Fix access controls, loader constraints. acorn parents: 12811 diff changeset	2680 // RC_TRACE_MESG macro has an embedded ResourceMark
ac9cb1d5a202 8009130: Lambda: Fix access controls, loader constraints. acorn parents: 12811 diff changeset	2681 RC_TRACE_MESG(("adjust: klassname=%s default methods from name=%s",
ac9cb1d5a202 8009130: Lambda: Fix access controls, loader constraints. acorn parents: 12811 diff changeset	2682 external_name(),
ac9cb1d5a202 8009130: Lambda: Fix access controls, loader constraints. acorn parents: 12811 diff changeset	2683 old_method->method_holder()->external_name()));
ac9cb1d5a202 8009130: Lambda: Fix access controls, loader constraints. acorn parents: 12811 diff changeset	2684 *trace_name_printed = true;
ac9cb1d5a202 8009130: Lambda: Fix access controls, loader constraints. acorn parents: 12811 diff changeset	2685 }
ac9cb1d5a202 8009130: Lambda: Fix access controls, loader constraints. acorn parents: 12811 diff changeset	2686 RC_TRACE(0x00100000, ("default method update: %s(%s) ",
ac9cb1d5a202 8009130: Lambda: Fix access controls, loader constraints. acorn parents: 12811 diff changeset	2687 new_method->name()->as_C_string(),
ac9cb1d5a202 8009130: Lambda: Fix access controls, loader constraints. acorn parents: 12811 diff changeset	2688 new_method->signature()->as_C_string()));
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 }
ac9cb1d5a202 8009130: Lambda: Fix access controls, loader constraints. acorn parents: 12811 diff changeset	2691 }
ac9cb1d5a202 8009130: Lambda: Fix access controls, loader constraints. acorn parents: 12811 diff changeset	2692 }
ac9cb1d5a202 8009130: Lambda: Fix access controls, loader constraints. acorn parents: 12811 diff changeset	2693 }
ac9cb1d5a202 8009130: Lambda: Fix access controls, loader constraints. acorn parents: 12811 diff changeset	2694 }
ac9cb1d5a202 8009130: Lambda: Fix access controls, loader constraints. acorn parents: 12811 diff changeset	2695 #endif // INCLUDE_JVMTI
ac9cb1d5a202 8009130: Lambda: Fix access controls, loader constraints. acorn parents: 12811 diff changeset	2696
0 a61af66fc99e Initial load duke parents: diff changeset	2697 // On-stack replacement stuff
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2698 void InstanceKlass::add_osr_nmethod(nmethod* n) {
0 a61af66fc99e Initial load duke parents: diff changeset	2699 // only one compilation can be active
a61af66fc99e Initial load duke parents: diff changeset	2700 NEEDS_CLEANUP
a61af66fc99e Initial load duke parents: diff changeset	2701 // This is a short non-blocking critical region, so the no safepoint check is ok.
a61af66fc99e Initial load duke parents: diff changeset	2702 OsrList_lock->lock_without_safepoint_check();
a61af66fc99e Initial load duke parents: diff changeset	2703 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	2704 n->set_osr_link(osr_nmethods_head());
0 a61af66fc99e Initial load duke parents: diff changeset	2705 set_osr_nmethods_head(n);
1783 d5d065957597 6953144: Tiered compilation iveresov parents: 1751 diff changeset	2706 // Raise the highest osr level if necessary
d5d065957597 6953144: Tiered compilation iveresov parents: 1751 diff changeset	2707 if (TieredCompilation) {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2708 Method* m = n->method();
1783 d5d065957597 6953144: Tiered compilation iveresov parents: 1751 diff changeset	2709 m->set_highest_osr_comp_level(MAX2(m->highest_osr_comp_level(), n->comp_level()));
d5d065957597 6953144: Tiered compilation iveresov parents: 1751 diff changeset	2710 }
0 a61af66fc99e Initial load duke parents: diff changeset	2711 // Remember to unlock again
a61af66fc99e Initial load duke parents: diff changeset	2712 OsrList_lock->unlock();
1783 d5d065957597 6953144: Tiered compilation iveresov parents: 1751 diff changeset	2713
d5d065957597 6953144: Tiered compilation iveresov parents: 1751 diff changeset	2714 // Get rid of the osr methods for the same bci that have lower levels.
d5d065957597 6953144: Tiered compilation iveresov parents: 1751 diff changeset	2715 if (TieredCompilation) {
d5d065957597 6953144: Tiered compilation iveresov parents: 1751 diff changeset	2716 for (int l = CompLevel_limited_profile; l < n->comp_level(); l++) {
d5d065957597 6953144: Tiered compilation iveresov parents: 1751 diff changeset	2717 nmethod *inv = lookup_osr_nmethod(n->method(), n->osr_entry_bci(), l, true);
d5d065957597 6953144: Tiered compilation iveresov parents: 1751 diff changeset	2718 if (inv != NULL && inv->is_in_use()) {
d5d065957597 6953144: Tiered compilation iveresov parents: 1751 diff changeset	2719 inv->make_not_entrant();
d5d065957597 6953144: Tiered compilation iveresov parents: 1751 diff changeset	2720 }
d5d065957597 6953144: Tiered compilation iveresov parents: 1751 diff changeset	2721 }
d5d065957597 6953144: Tiered compilation iveresov parents: 1751 diff changeset	2722 }
0 a61af66fc99e Initial load duke parents: diff changeset	2723 }
a61af66fc99e Initial load duke parents: diff changeset	2724
a61af66fc99e Initial load duke parents: diff changeset	2725
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2726 void InstanceKlass::remove_osr_nmethod(nmethod* n) {
0 a61af66fc99e Initial load duke parents: diff changeset	2727 // This is a short non-blocking critical region, so the no safepoint check is ok.
a61af66fc99e Initial load duke parents: diff changeset	2728 OsrList_lock->lock_without_safepoint_check();
a61af66fc99e Initial load duke parents: diff changeset	2729 assert(n->is_osr_method(), "wrong kind of nmethod");
a61af66fc99e Initial load duke parents: diff changeset	2730 nmethod* last = NULL;
a61af66fc99e Initial load duke parents: diff changeset	2731 nmethod* cur = osr_nmethods_head();
1783 d5d065957597 6953144: Tiered compilation iveresov parents: 1751 diff changeset	2732 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	2733 Method* m = n->method();
0 a61af66fc99e Initial load duke parents: diff changeset	2734 // Search for match
a61af66fc99e Initial load duke parents: diff changeset	2735 while(cur != NULL && cur != n) {
1783 d5d065957597 6953144: Tiered compilation iveresov parents: 1751 diff changeset	2736 if (TieredCompilation) {
d5d065957597 6953144: Tiered compilation iveresov parents: 1751 diff changeset	2737 // Find max level before n
d5d065957597 6953144: Tiered compilation iveresov parents: 1751 diff changeset	2738 max_level = MAX2(max_level, cur->comp_level());
d5d065957597 6953144: Tiered compilation iveresov parents: 1751 diff changeset	2739 }
0 a61af66fc99e Initial load duke parents: diff changeset	2740 last = cur;
989 148e5441d916 6863023: need non-perm oops in code cache for JSR 292 jrose parents: 876 diff changeset	2741 cur = cur->osr_link();
0 a61af66fc99e Initial load duke parents: diff changeset	2742 }
1783 d5d065957597 6953144: Tiered compilation iveresov parents: 1751 diff changeset	2743 nmethod* next = NULL;
0 a61af66fc99e Initial load duke parents: diff changeset	2744 if (cur == n) {
1783 d5d065957597 6953144: Tiered compilation iveresov parents: 1751 diff changeset	2745 next = cur->osr_link();
0 a61af66fc99e Initial load duke parents: diff changeset	2746 if (last == NULL) {
a61af66fc99e Initial load duke parents: diff changeset	2747 // Remove first element
1783 d5d065957597 6953144: Tiered compilation iveresov parents: 1751 diff changeset	2748 set_osr_nmethods_head(next);
0 a61af66fc99e Initial load duke parents: diff changeset	2749 } else {
1783 d5d065957597 6953144: Tiered compilation iveresov parents: 1751 diff changeset	2750 last->set_osr_link(next);
0 a61af66fc99e Initial load duke parents: diff changeset	2751 }
a61af66fc99e Initial load duke parents: diff changeset	2752 }
989 148e5441d916 6863023: need non-perm oops in code cache for JSR 292 jrose parents: 876 diff changeset	2753 n->set_osr_link(NULL);
1783 d5d065957597 6953144: Tiered compilation iveresov parents: 1751 diff changeset	2754 if (TieredCompilation) {
d5d065957597 6953144: Tiered compilation iveresov parents: 1751 diff changeset	2755 cur = next;
d5d065957597 6953144: Tiered compilation iveresov parents: 1751 diff changeset	2756 while (cur != NULL) {
d5d065957597 6953144: Tiered compilation iveresov parents: 1751 diff changeset	2757 // Find max level after n
d5d065957597 6953144: Tiered compilation iveresov parents: 1751 diff changeset	2758 max_level = MAX2(max_level, cur->comp_level());
d5d065957597 6953144: Tiered compilation iveresov parents: 1751 diff changeset	2759 cur = cur->osr_link();
d5d065957597 6953144: Tiered compilation iveresov parents: 1751 diff changeset	2760 }
d5d065957597 6953144: Tiered compilation iveresov parents: 1751 diff changeset	2761 m->set_highest_osr_comp_level(max_level);
d5d065957597 6953144: Tiered compilation iveresov parents: 1751 diff changeset	2762 }
0 a61af66fc99e Initial load duke parents: diff changeset	2763 // Remember to unlock again
a61af66fc99e Initial load duke parents: diff changeset	2764 OsrList_lock->unlock();
a61af66fc99e Initial load duke parents: diff changeset	2765 }
a61af66fc99e Initial load duke parents: diff changeset	2766
10265 92ef81e2f571 8003557: NPG: Klass* const k should be const Klass* k. minqi parents: 10152 diff changeset	2767 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	2768 // This is a short non-blocking critical region, so the no safepoint check is ok.
a61af66fc99e Initial load duke parents: diff changeset	2769 OsrList_lock->lock_without_safepoint_check();
a61af66fc99e Initial load duke parents: diff changeset	2770 nmethod* osr = osr_nmethods_head();
1783 d5d065957597 6953144: Tiered compilation iveresov parents: 1751 diff changeset	2771 nmethod* best = NULL;
0 a61af66fc99e Initial load duke parents: diff changeset	2772 while (osr != NULL) {
a61af66fc99e Initial load duke parents: diff changeset	2773 assert(osr->is_osr_method(), "wrong kind of nmethod found in chain");
1783 d5d065957597 6953144: Tiered compilation iveresov parents: 1751 diff changeset	2774 // There can be a time when a c1 osr method exists but we are waiting
d5d065957597 6953144: Tiered compilation iveresov parents: 1751 diff changeset	2775 // for a c2 version. When c2 completes its osr nmethod we will trash
d5d065957597 6953144: Tiered compilation iveresov parents: 1751 diff changeset	2776 // the c1 version and only be able to find the c2 version. However
d5d065957597 6953144: Tiered compilation iveresov parents: 1751 diff changeset	2777 // while we overflow in the c1 code at back branches we don't want to
d5d065957597 6953144: Tiered compilation iveresov parents: 1751 diff changeset	2778 // try and switch to the same code as we are already running
d5d065957597 6953144: Tiered compilation iveresov parents: 1751 diff changeset	2779
0 a61af66fc99e Initial load duke parents: diff changeset	2780 if (osr->method() == m &&
a61af66fc99e Initial load duke parents: diff changeset	2781 (bci == InvocationEntryBci \|\| osr->osr_entry_bci() == bci)) {
1783 d5d065957597 6953144: Tiered compilation iveresov parents: 1751 diff changeset	2782 if (match_level) {
d5d065957597 6953144: Tiered compilation iveresov parents: 1751 diff changeset	2783 if (osr->comp_level() == comp_level) {
d5d065957597 6953144: Tiered compilation iveresov parents: 1751 diff changeset	2784 // Found a match - return it.
d5d065957597 6953144: Tiered compilation iveresov parents: 1751 diff changeset	2785 OsrList_lock->unlock();
d5d065957597 6953144: Tiered compilation iveresov parents: 1751 diff changeset	2786 return osr;
d5d065957597 6953144: Tiered compilation iveresov parents: 1751 diff changeset	2787 }
d5d065957597 6953144: Tiered compilation iveresov parents: 1751 diff changeset	2788 } else {
d5d065957597 6953144: Tiered compilation iveresov parents: 1751 diff changeset	2789 if (best == NULL \|\| (osr->comp_level() > best->comp_level())) {
d5d065957597 6953144: Tiered compilation iveresov parents: 1751 diff changeset	2790 if (osr->comp_level() == CompLevel_highest_tier) {
d5d065957597 6953144: Tiered compilation iveresov parents: 1751 diff changeset	2791 // Found the best possible - return it.
d5d065957597 6953144: Tiered compilation iveresov parents: 1751 diff changeset	2792 OsrList_lock->unlock();
d5d065957597 6953144: Tiered compilation iveresov parents: 1751 diff changeset	2793 return osr;
d5d065957597 6953144: Tiered compilation iveresov parents: 1751 diff changeset	2794 }
d5d065957597 6953144: Tiered compilation iveresov parents: 1751 diff changeset	2795 best = osr;
d5d065957597 6953144: Tiered compilation iveresov parents: 1751 diff changeset	2796 }
d5d065957597 6953144: Tiered compilation iveresov parents: 1751 diff changeset	2797 }
0 a61af66fc99e Initial load duke parents: diff changeset	2798 }
989 148e5441d916 6863023: need non-perm oops in code cache for JSR 292 jrose parents: 876 diff changeset	2799 osr = osr->osr_link();
0 a61af66fc99e Initial load duke parents: diff changeset	2800 }
a61af66fc99e Initial load duke parents: diff changeset	2801 OsrList_lock->unlock();
1783 d5d065957597 6953144: Tiered compilation iveresov parents: 1751 diff changeset	2802 if (best != NULL && best->comp_level() >= comp_level && match_level == false) {
d5d065957597 6953144: Tiered compilation iveresov parents: 1751 diff changeset	2803 return best;
d5d065957597 6953144: Tiered compilation iveresov parents: 1751 diff changeset	2804 }
0 a61af66fc99e Initial load duke parents: diff changeset	2805 return NULL;
a61af66fc99e Initial load duke parents: diff changeset	2806 }
a61af66fc99e Initial load duke parents: diff changeset	2807
10345 b7fa10a3a69a 8014288: perf regression in nashorn JDK-8008448.js test after 8008511 changes sspitsyn parents: 10343 diff changeset	2808 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	2809 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	2810 MutexLocker ml(MemberNameTable_lock);
10345 b7fa10a3a69a 8014288: perf regression in nashorn JDK-8008448.js test after 8008511 changes sspitsyn parents: 10343 diff changeset	2811 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	2812 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	2813
6337ca4dcad8 8008511: JSR 292: MemberName vmtarget refs to methods must be updated at class redefinition sspitsyn parents: 9062 diff changeset	2814 if (_member_names == NULL) {
10345 b7fa10a3a69a 8014288: perf regression in nashorn JDK-8008448.js test after 8008511 changes sspitsyn parents: 10343 diff changeset	2815 _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	2816 }
10345 b7fa10a3a69a 8014288: perf regression in nashorn JDK-8008448.js test after 8008511 changes sspitsyn parents: 10343 diff changeset	2817 _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	2818 }
b7fa10a3a69a 8014288: perf regression in nashorn JDK-8008448.js test after 8008511 changes sspitsyn parents: 10343 diff changeset	2819
b7fa10a3a69a 8014288: perf regression in nashorn JDK-8008448.js test after 8008511 changes sspitsyn parents: 10343 diff changeset	2820 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	2821 MutexLocker ml(MemberNameTable_lock);
b7fa10a3a69a 8014288: perf regression in nashorn JDK-8008448.js test after 8008511 changes sspitsyn parents: 10343 diff changeset	2822 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	2823 DEBUG_ONLY(No_Safepoint_Verifier nsv);
b7fa10a3a69a 8014288: perf regression in nashorn JDK-8008448.js test after 8008511 changes sspitsyn parents: 10343 diff changeset	2824
b7fa10a3a69a 8014288: perf regression in nashorn JDK-8008448.js test after 8008511 changes sspitsyn parents: 10343 diff changeset	2825 if (_member_names == NULL) {
b7fa10a3a69a 8014288: perf regression in nashorn JDK-8008448.js test after 8008511 changes sspitsyn parents: 10343 diff changeset	2826 return NULL;
b7fa10a3a69a 8014288: perf regression in nashorn JDK-8008448.js test after 8008511 changes sspitsyn parents: 10343 diff changeset	2827 }
b7fa10a3a69a 8014288: perf regression in nashorn JDK-8008448.js test after 8008511 changes sspitsyn parents: 10343 diff changeset	2828 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	2829 return mem_name;
10133 6337ca4dcad8 8008511: JSR 292: MemberName vmtarget refs to methods must be updated at class redefinition sspitsyn parents: 9062 diff changeset	2830 }
6337ca4dcad8 8008511: JSR 292: MemberName vmtarget refs to methods must be updated at class redefinition sspitsyn parents: 9062 diff changeset	2831
0 a61af66fc99e Initial load duke parents: diff changeset	2832 // -----------------------------------------------------------------------------------------------------
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2833 // Printing
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2834
0 a61af66fc99e Initial load duke parents: diff changeset	2835 #ifndef PRODUCT
a61af66fc99e Initial load duke parents: diff changeset	2836
665 c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 605 diff changeset	2837 #define BULLET " - "
c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 605 diff changeset	2838
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2839 static const char* state_names[] = {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2840 "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	2841 };
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2842
12264 b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 12067 diff changeset	2843 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	2844 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	2845 intptr_t e = start[i];
b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 12067 diff changeset	2846 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	2847 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	2848 st->print(" ");
b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 12067 diff changeset	2849 ((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	2850 }
b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 12067 diff changeset	2851 st->cr();
b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 12067 diff changeset	2852 }
b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 12067 diff changeset	2853 }
b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 12067 diff changeset	2854
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2855 void InstanceKlass::print_on(outputStream* st) const {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2856 assert(is_klass(), "must be klass");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2857 Klass::print_on(st);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2858
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2859 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	2860 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	2861 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	2862 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	2863 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	2864 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	2865 st->print(BULLET"sub: ");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2866 Klass* sub = subklass();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2867 int n;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2868 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	2869 if (n < MaxSubklassPrintSize) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2870 sub->print_value_on(st);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2871 st->print(" ");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2872 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2873 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2874 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	2875 st->cr();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2876
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2877 if (is_interface()) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2878 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	2879 if (nof_implementors() == 1) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2880 st->print_cr(BULLET"implementor: ");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2881 st->print(" ");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2882 implementor()->print_value_on(st);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2883 st->cr();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2884 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2885 }
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"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	2888 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	2889 if (Verbose \|\| WizardMode) {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2890 Array<Method> method_array = methods();
12823 ac9cb1d5a202 8009130: Lambda: Fix access controls, loader constraints. acorn parents: 12811 diff changeset	2891 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	2892 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	2893 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2894 }
12823 ac9cb1d5a202 8009130: Lambda: Fix access controls, loader constraints. acorn parents: 12811 diff changeset	2895 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	2896 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	2897 if (Verbose && default_methods() != NULL) {
ac9cb1d5a202 8009130: Lambda: Fix access controls, loader constraints. acorn parents: 12811 diff changeset	2898 Array<Method> method_array = default_methods();
ac9cb1d5a202 8009130: Lambda: Fix access controls, loader constraints. acorn parents: 12811 diff changeset	2899 for (int i = 0; i < method_array->length(); i++) {
ac9cb1d5a202 8009130: Lambda: Fix access controls, loader constraints. acorn parents: 12811 diff changeset	2900 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	2901 }
ac9cb1d5a202 8009130: Lambda: Fix access controls, loader constraints. acorn parents: 12811 diff changeset	2902 }
ac9cb1d5a202 8009130: Lambda: Fix access controls, loader constraints. acorn parents: 12811 diff changeset	2903 if (default_vtable_indices() != NULL) {
ac9cb1d5a202 8009130: Lambda: Fix access controls, loader constraints. acorn parents: 12811 diff changeset	2904 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	2905 }
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2906 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	2907 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	2908 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	2909 if (class_loader_data() != NULL) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2910 st->print(BULLET"class loader data: ");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2911 class_loader_data()->print_value_on(st);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2912 st->cr();
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 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	2915 if (source_file_name() != NULL) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2916 st->print(BULLET"source file: ");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2917 source_file_name()->print_value_on(st);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2918 st->cr();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2919 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2920 if (source_debug_extension() != NULL) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2921 st->print(BULLET"source debug extension: ");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2922 st->print("%s", source_debug_extension());
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2923 st->cr();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2924 }
8031 927a311d00f9 8007320: NPG: move method annotations coleenp parents: 8003 diff changeset	2925 st->print(BULLET"class annotations: "); class_annotations()->print_value_on(st); st->cr();
927a311d00f9 8007320: NPG: move method annotations coleenp parents: 8003 diff changeset	2926 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	2927 st->print(BULLET"field annotations: "); fields_annotations()->print_value_on(st); st->cr();
927a311d00f9 8007320: NPG: move method annotations coleenp parents: 8003 diff changeset	2928 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	2929 {
12281 4f9a42c33738 8022887: Assertion hit while using class and redefining it with RedefineClasses simultaneously coleenp parents: 12067 diff changeset	2930 bool have_pv = false;
4f9a42c33738 8022887: Assertion hit while using class and redefining it with RedefineClasses simultaneously coleenp parents: 12067 diff changeset	2931 PreviousVersionWalker pvw(Thread::current(), (InstanceKlass*)this);
4f9a42c33738 8022887: Assertion hit while using class and redefining it with RedefineClasses simultaneously coleenp parents: 12067 diff changeset	2932 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	2933 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	2934 if (!have_pv)
4f9a42c33738 8022887: Assertion hit while using class and redefining it with RedefineClasses simultaneously coleenp parents: 12067 diff changeset	2935 st->print(BULLET"previous version: ");
4f9a42c33738 8022887: Assertion hit while using class and redefining it with RedefineClasses simultaneously coleenp parents: 12067 diff changeset	2936 have_pv = true;
4f9a42c33738 8022887: Assertion hit while using class and redefining it with RedefineClasses simultaneously coleenp parents: 12067 diff changeset	2937 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	2938 }
4f9a42c33738 8022887: Assertion hit while using class and redefining it with RedefineClasses simultaneously coleenp parents: 12067 diff changeset	2939 if (have_pv) st->cr();
4f9a42c33738 8022887: Assertion hit while using class and redefining it with RedefineClasses simultaneously coleenp parents: 12067 diff changeset	2940 } // pvw is cleaned up
6725 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 if (generic_signature() != NULL) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2943 st->print(BULLET"generic signature: ");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2944 generic_signature()->print_value_on(st);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2945 st->cr();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2946 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2947 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	2948 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	2949 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	2950 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	2951 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	2952 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	2953 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	2954 FieldPrinter print_static_field(st);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2955 ((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	2956 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	2957 FieldPrinter print_nonstatic_field(st);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2958 ((InstanceKlass*)this)->do_nonstatic_fields(&print_nonstatic_field);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2959
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2960 st->print(BULLET"non-static oop maps: ");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2961 OopMapBlock* map = start_of_nonstatic_oop_maps();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2962 OopMapBlock* end_map = map + nonstatic_oop_map_count();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2963 while (map < end_map) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2964 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	2965 map++;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2966 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2967 st->cr();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2968 }
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 #endif //PRODUCT
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2971
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2972 void InstanceKlass::print_value_on(outputStream* st) const {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2973 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	2974 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	2975 name()->print_value_on(st);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2976 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2977
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2978 #ifndef PRODUCT
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2979
0 a61af66fc99e Initial load duke parents: diff changeset	2980 void FieldPrinter::do_field(fieldDescriptor* fd) {
665 c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 605 diff changeset	2981 _st->print(BULLET);
2376 c7f3d0b4570f 7017732: move static fields into Class to prepare for perm gen removal never parents: 2357 diff changeset	2982 if (_obj == NULL) {
0 a61af66fc99e Initial load duke parents: diff changeset	2983 fd->print_on(_st);
a61af66fc99e Initial load duke parents: diff changeset	2984 _st->cr();
a61af66fc99e Initial load duke parents: diff changeset	2985 } else {
a61af66fc99e Initial load duke parents: diff changeset	2986 fd->print_on_for(_st, _obj);
a61af66fc99e Initial load duke parents: diff changeset	2987 _st->cr();
a61af66fc99e Initial load duke parents: diff changeset	2988 }
a61af66fc99e Initial load duke parents: diff changeset	2989 }
a61af66fc99e Initial load duke parents: diff changeset	2990
a61af66fc99e Initial load duke parents: diff changeset	2991
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2992 void InstanceKlass::oop_print_on(oop obj, outputStream* st) {
0 a61af66fc99e Initial load duke parents: diff changeset	2993 Klass::oop_print_on(obj, st);
a61af66fc99e Initial load duke parents: diff changeset	2994
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2995 if (this == SystemDictionary::String_klass()) {
0 a61af66fc99e Initial load duke parents: diff changeset	2996 typeArrayOop value = java_lang_String::value(obj);
a61af66fc99e Initial load duke parents: diff changeset	2997 juint offset = java_lang_String::offset(obj);
a61af66fc99e Initial load duke parents: diff changeset	2998 juint length = java_lang_String::length(obj);
a61af66fc99e Initial load duke parents: diff changeset	2999 if (value != NULL &&
a61af66fc99e Initial load duke parents: diff changeset	3000 value->is_typeArray() &&
a61af66fc99e Initial load duke parents: diff changeset	3001 offset <= (juint) value->length() &&
a61af66fc99e Initial load duke parents: diff changeset	3002 offset + length <= (juint) value->length()) {
665 c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 605 diff changeset	3003 st->print(BULLET"string: ");
0 a61af66fc99e Initial load duke parents: diff changeset	3004 Handle h_obj(obj);
a61af66fc99e Initial load duke parents: diff changeset	3005 java_lang_String::print(h_obj, st);
a61af66fc99e Initial load duke parents: diff changeset	3006 st->cr();
a61af66fc99e Initial load duke parents: diff changeset	3007 if (!WizardMode) return; // that is enough
a61af66fc99e Initial load duke parents: diff changeset	3008 }
a61af66fc99e Initial load duke parents: diff changeset	3009 }
a61af66fc99e Initial load duke parents: diff changeset	3010
665 c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 605 diff changeset	3011 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	3012 FieldPrinter print_field(st, obj);
c7f3d0b4570f 7017732: move static fields into Class to prepare for perm gen removal never parents: 2357 diff changeset	3013 do_nonstatic_fields(&print_field);
0 a61af66fc99e Initial load duke parents: diff changeset	3014
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3015 if (this == SystemDictionary::Class_klass()) {
665 c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 605 diff changeset	3016 st->print(BULLET"signature: ");
c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 605 diff changeset	3017 java_lang_Class::print_signature(obj, st);
c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 605 diff changeset	3018 st->cr();
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3019 Klass* mirrored_klass = java_lang_Class::as_Klass(obj);
665 c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 605 diff changeset	3020 st->print(BULLET"fake entry for mirror: ");
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3021 mirrored_klass->print_value_on_maybe_null(st);
0 a61af66fc99e Initial load duke parents: diff changeset	3022 st->cr();
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3023 Klass* array_klass = java_lang_Class::array_klass(obj);
665 c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 605 diff changeset	3024 st->print(BULLET"fake entry for array: ");
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3025 array_klass->print_value_on_maybe_null(st);
0 a61af66fc99e Initial load duke parents: diff changeset	3026 st->cr();
2376 c7f3d0b4570f 7017732: move static fields into Class to prepare for perm gen removal never parents: 2357 diff changeset	3027 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	3028 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	3029 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	3030 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	3031 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	3032 }
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3033 } else if (this == SystemDictionary::MethodType_klass()) {
1039 987e948ebbc8 6815692: method handle code needs some cleanup (post-6655638) jrose parents: 997 diff changeset	3034 st->print(BULLET"signature: ");
2357 8033953d67ff 7012648: move JSR 292 to package java.lang.invoke and adjust names jrose parents: 2334 diff changeset	3035 java_lang_invoke_MethodType::print_signature(obj, st);
1039 987e948ebbc8 6815692: method handle code needs some cleanup (post-6655638) jrose parents: 997 diff changeset	3036 st->cr();
0 a61af66fc99e Initial load duke parents: diff changeset	3037 }
a61af66fc99e Initial load duke parents: diff changeset	3038 }
a61af66fc99e Initial load duke parents: diff changeset	3039
1155 4e6abf09f540 6912062: disassembler plugin needs to produce symbolic information in product mode jrose parents: 1144 diff changeset	3040 #endif //PRODUCT
4e6abf09f540 6912062: disassembler plugin needs to produce symbolic information in product mode jrose parents: 1144 diff changeset	3041
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3042 void InstanceKlass::oop_print_value_on(oop obj, outputStream* st) {
0 a61af66fc99e Initial load duke parents: diff changeset	3043 st->print("a ");
a61af66fc99e Initial load duke parents: diff changeset	3044 name()->print_value_on(st);
a61af66fc99e Initial load duke parents: diff changeset	3045 obj->print_address_on(st);
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3046 if (this == SystemDictionary::String_klass()
665 c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 605 diff changeset	3047 && java_lang_String::value(obj) != NULL) {
c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 605 diff changeset	3048 ResourceMark rm;
c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 605 diff changeset	3049 int len = java_lang_String::length(obj);
c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 605 diff changeset	3050 int plen = (len < 24 ? len : 12);
c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 605 diff changeset	3051 char* str = java_lang_String::as_utf8_string(obj, 0, plen);
c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 605 diff changeset	3052 st->print(" = \"%s\"", str);
c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 605 diff changeset	3053 if (len > plen)
c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 605 diff changeset	3054 st->print("...[%d]", len);
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3055 } else if (this == SystemDictionary::Class_klass()) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3056 Klass* k = java_lang_Class::as_Klass(obj);
665 c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 605 diff changeset	3057 st->print(" = ");
c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 605 diff changeset	3058 if (k != NULL) {
c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 605 diff changeset	3059 k->print_value_on(st);
c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 605 diff changeset	3060 } else {
c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 605 diff changeset	3061 const char* tname = type2name(java_lang_Class::primitive_type(obj));
c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 605 diff changeset	3062 st->print("%s", tname ? tname : "type?");
c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 605 diff changeset	3063 }
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3064 } else if (this == SystemDictionary::MethodType_klass()) {
1039 987e948ebbc8 6815692: method handle code needs some cleanup (post-6655638) jrose parents: 997 diff changeset	3065 st->print(" = ");
2357 8033953d67ff 7012648: move JSR 292 to package java.lang.invoke and adjust names jrose parents: 2334 diff changeset	3066 java_lang_invoke_MethodType::print_signature(obj, st);
665 c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 605 diff changeset	3067 } else if (java_lang_boxing_object::is_instance(obj)) {
c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 605 diff changeset	3068 st->print(" = ");
c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 605 diff changeset	3069 java_lang_boxing_object::print(obj, st);
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3070 } 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	3071 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	3072 if (vmentry != NULL) {
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 6203 diff changeset	3073 st->print(" => ");
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 6203 diff changeset	3074 vmentry->print_value_on(st);
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 6203 diff changeset	3075 }
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3076 } else if (this == SystemDictionary::MemberName_klass()) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3077 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	3078 if (vmtarget != NULL) {
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 6203 diff changeset	3079 st->print(" = ");
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 6203 diff changeset	3080 vmtarget->print_value_on(st);
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 6203 diff changeset	3081 } else {
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 6203 diff changeset	3082 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	3083 st->print(".");
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 6203 diff changeset	3084 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	3085 }
665 c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 605 diff changeset	3086 }
0 a61af66fc99e Initial load duke parents: diff changeset	3087 }
a61af66fc99e Initial load duke parents: diff changeset	3088
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3089 const char* InstanceKlass::internal_name() const {
0 a61af66fc99e Initial load duke parents: diff changeset	3090 return external_name();
a61af66fc99e Initial load duke parents: diff changeset	3091 }
a61af66fc99e Initial load duke parents: diff changeset	3092
7956 16fb9f942703 6479360: PrintClassHistogram improvements acorn parents: 7610 diff changeset	3093 #if INCLUDE_SERVICES
16fb9f942703 6479360: PrintClassHistogram improvements acorn parents: 7610 diff changeset	3094 // Size Statistics
16fb9f942703 6479360: PrintClassHistogram improvements acorn parents: 7610 diff changeset	3095 void InstanceKlass::collect_statistics(KlassSizeStats *sz) const {
16fb9f942703 6479360: PrintClassHistogram improvements acorn parents: 7610 diff changeset	3096 Klass::collect_statistics(sz);
16fb9f942703 6479360: PrintClassHistogram improvements acorn parents: 7610 diff changeset	3097
16fb9f942703 6479360: PrintClassHistogram improvements acorn parents: 7610 diff changeset	3098 sz->_inst_size = HeapWordSize * size_helper();
16fb9f942703 6479360: PrintClassHistogram improvements acorn parents: 7610 diff changeset	3099 sz->_vtab_bytes = HeapWordSize * align_object_offset(vtable_length());
16fb9f942703 6479360: PrintClassHistogram improvements acorn parents: 7610 diff changeset	3100 sz->_itab_bytes = HeapWordSize * align_object_offset(itable_length());
16fb9f942703 6479360: PrintClassHistogram improvements acorn parents: 7610 diff changeset	3101 sz->_nonstatic_oopmap_bytes = HeapWordSize *
16fb9f942703 6479360: PrintClassHistogram improvements acorn parents: 7610 diff changeset	3102 ((is_interface() \|\| is_anonymous()) ?
16fb9f942703 6479360: PrintClassHistogram improvements acorn parents: 7610 diff changeset	3103 align_object_offset(nonstatic_oop_map_size()) :
16fb9f942703 6479360: PrintClassHistogram improvements acorn parents: 7610 diff changeset	3104 nonstatic_oop_map_size());
16fb9f942703 6479360: PrintClassHistogram improvements acorn parents: 7610 diff changeset	3105
16fb9f942703 6479360: PrintClassHistogram improvements acorn parents: 7610 diff changeset	3106 int n = 0;
16fb9f942703 6479360: PrintClassHistogram improvements acorn parents: 7610 diff changeset	3107 n += (sz->_methods_array_bytes = sz->count_array(methods()));
16fb9f942703 6479360: PrintClassHistogram improvements acorn parents: 7610 diff changeset	3108 n += (sz->_method_ordering_bytes = sz->count_array(method_ordering()));
16fb9f942703 6479360: PrintClassHistogram improvements acorn parents: 7610 diff changeset	3109 n += (sz->_local_interfaces_bytes = sz->count_array(local_interfaces()));
16fb9f942703 6479360: PrintClassHistogram improvements acorn parents: 7610 diff changeset	3110 n += (sz->_transitive_interfaces_bytes = sz->count_array(transitive_interfaces()));
16fb9f942703 6479360: PrintClassHistogram improvements acorn parents: 7610 diff changeset	3111 n += (sz->_fields_bytes = sz->count_array(fields()));
16fb9f942703 6479360: PrintClassHistogram improvements acorn parents: 7610 diff changeset	3112 n += (sz->_inner_classes_bytes = sz->count_array(inner_classes()));
16fb9f942703 6479360: PrintClassHistogram improvements acorn parents: 7610 diff changeset	3113 sz->_ro_bytes += n;
16fb9f942703 6479360: PrintClassHistogram improvements acorn parents: 7610 diff changeset	3114
16fb9f942703 6479360: PrintClassHistogram improvements acorn parents: 7610 diff changeset	3115 const ConstantPool* cp = constants();
16fb9f942703 6479360: PrintClassHistogram improvements acorn parents: 7610 diff changeset	3116 if (cp) {
16fb9f942703 6479360: PrintClassHistogram improvements acorn parents: 7610 diff changeset	3117 cp->collect_statistics(sz);
16fb9f942703 6479360: PrintClassHistogram improvements acorn parents: 7610 diff changeset	3118 }
16fb9f942703 6479360: PrintClassHistogram improvements acorn parents: 7610 diff changeset	3119
16fb9f942703 6479360: PrintClassHistogram improvements acorn parents: 7610 diff changeset	3120 const Annotations* anno = annotations();
16fb9f942703 6479360: PrintClassHistogram improvements acorn parents: 7610 diff changeset	3121 if (anno) {
16fb9f942703 6479360: PrintClassHistogram improvements acorn parents: 7610 diff changeset	3122 anno->collect_statistics(sz);
16fb9f942703 6479360: PrintClassHistogram improvements acorn parents: 7610 diff changeset	3123 }
16fb9f942703 6479360: PrintClassHistogram improvements acorn parents: 7610 diff changeset	3124
16fb9f942703 6479360: PrintClassHistogram improvements acorn parents: 7610 diff changeset	3125 const Array<Method> methods_array = methods();
16fb9f942703 6479360: PrintClassHistogram improvements acorn parents: 7610 diff changeset	3126 if (methods()) {
16fb9f942703 6479360: PrintClassHistogram improvements acorn parents: 7610 diff changeset	3127 for (int i = 0; i < methods_array->length(); i++) {
16fb9f942703 6479360: PrintClassHistogram improvements acorn parents: 7610 diff changeset	3128 Method* method = methods_array->at(i);
16fb9f942703 6479360: PrintClassHistogram improvements acorn parents: 7610 diff changeset	3129 if (method) {
16fb9f942703 6479360: PrintClassHistogram improvements acorn parents: 7610 diff changeset	3130 sz->_method_count ++;
16fb9f942703 6479360: PrintClassHistogram improvements acorn parents: 7610 diff changeset	3131 method->collect_statistics(sz);
16fb9f942703 6479360: PrintClassHistogram improvements acorn parents: 7610 diff changeset	3132 }
16fb9f942703 6479360: PrintClassHistogram improvements acorn parents: 7610 diff changeset	3133 }
16fb9f942703 6479360: PrintClassHistogram improvements acorn parents: 7610 diff changeset	3134 }
16fb9f942703 6479360: PrintClassHistogram improvements acorn parents: 7610 diff changeset	3135 }
16fb9f942703 6479360: PrintClassHistogram improvements acorn parents: 7610 diff changeset	3136 #endif // INCLUDE_SERVICES
16fb9f942703 6479360: PrintClassHistogram improvements acorn parents: 7610 diff changeset	3137
0 a61af66fc99e Initial load duke parents: diff changeset	3138 // Verification
a61af66fc99e Initial load duke parents: diff changeset	3139
a61af66fc99e Initial load duke parents: diff changeset	3140 class VerifyFieldClosure: public OopClosure {
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	3141 protected:
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	3142 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	3143 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	3144 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	3145 tty->print_cr("Failed: " PTR_FORMAT " -> " PTR_FORMAT, p, (address)obj);
0 a61af66fc99e Initial load duke parents: diff changeset	3146 Universe::print();
a61af66fc99e Initial load duke parents: diff changeset	3147 guarantee(false, "boom");
a61af66fc99e Initial load duke parents: diff changeset	3148 }
a61af66fc99e Initial load duke parents: diff changeset	3149 }
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	3150 public:
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	3151 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	3152 virtual void do_oop(narrowOop* p) { VerifyFieldClosure::do_oop_work(p); }
0 a61af66fc99e Initial load duke parents: diff changeset	3153 };
a61af66fc99e Initial load duke parents: diff changeset	3154
11034 e0c9a1d29eb4 8016325: JVM hangs verifying system dictionary coleenp parents: 10347 diff changeset	3155 void InstanceKlass::verify_on(outputStream* st, bool check_dictionary) {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3156 #ifndef PRODUCT
11034 e0c9a1d29eb4 8016325: JVM hangs verifying system dictionary coleenp parents: 10347 diff changeset	3157 // 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	3158 if (_verify_count == Universe::verify_count()) return;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3159 _verify_count = Universe::verify_count();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3160 #endif
11034 e0c9a1d29eb4 8016325: JVM hangs verifying system dictionary coleenp parents: 10347 diff changeset	3161
e0c9a1d29eb4 8016325: JVM hangs verifying system dictionary coleenp parents: 10347 diff changeset	3162 // Verify Klass
e0c9a1d29eb4 8016325: JVM hangs verifying system dictionary coleenp parents: 10347 diff changeset	3163 Klass::verify_on(st, check_dictionary);
e0c9a1d29eb4 8016325: JVM hangs verifying system dictionary coleenp parents: 10347 diff changeset	3164
e0c9a1d29eb4 8016325: JVM hangs verifying system dictionary coleenp parents: 10347 diff changeset	3165 // Verify that klass is present in SystemDictionary if not already
e0c9a1d29eb4 8016325: JVM hangs verifying system dictionary coleenp parents: 10347 diff changeset	3166 // verifying the SystemDictionary.
e0c9a1d29eb4 8016325: JVM hangs verifying system dictionary coleenp parents: 10347 diff changeset	3167 if (is_loaded() && !is_anonymous() && check_dictionary) {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3168 Symbol* h_name = name();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3169 SystemDictionary::verify_obj_klass_present(h_name, class_loader_data());
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3170 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3171
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3172 // Verify vtables
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3173 if (is_linked()) {
11034 e0c9a1d29eb4 8016325: JVM hangs verifying system dictionary coleenp parents: 10347 diff changeset	3174 ResourceMark rm;
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3175 // $$$ 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	3176 // always seemed a valid generalization. (DLD -- 6/00)
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3177 vtable()->verify(st);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3178 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3179
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3180 // Verify first subklass
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3181 if (subklass_oop() != NULL) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3182 guarantee(subklass_oop()->is_klass(), "should be klass");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3183 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3184
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3185 // Verify siblings
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3186 Klass* super = this->super();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3187 Klass* sib = next_sibling();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3188 if (sib != NULL) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3189 if (sib == this) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3190 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	3191 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3192
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3193 guarantee(sib->is_klass(), "should be klass");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3194 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	3195 }
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 implementor fields
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3198 Klass* im = implementor();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3199 if (im != NULL) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3200 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	3201 guarantee(im->is_klass(), "should be klass");
6983 070d523b96a7 8001471: Klass::cast() does nothing hseigel parents: 6934 diff changeset	3202 guarantee(!im->is_interface() \|\| im == this,
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3203 "implementors cannot be interfaces");
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
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3206 // Verify local interfaces
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3207 if (local_interfaces()) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3208 Array<Klass> local_interfaces = this->local_interfaces();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3209 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	3210 Klass* e = local_interfaces->at(j);
6983 070d523b96a7 8001471: Klass::cast() does nothing hseigel parents: 6934 diff changeset	3211 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	3212 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3213 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3214
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3215 // Verify transitive interfaces
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3216 if (transitive_interfaces() != NULL) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3217 Array<Klass> transitive_interfaces = this->transitive_interfaces();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3218 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	3219 Klass* e = transitive_interfaces->at(j);
6983 070d523b96a7 8001471: Klass::cast() does nothing hseigel parents: 6934 diff changeset	3220 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	3221 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3222 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3223
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3224 // Verify methods
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3225 if (methods() != NULL) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3226 Array<Method> methods = this->methods();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3227 for (int j = 0; j < methods->length(); j++) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3228 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	3229 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3230 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	3231 Method* m1 = methods->at(j);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3232 Method* m2 = methods->at(j + 1);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3233 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	3234 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3235 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3236
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3237 // Verify method ordering
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3238 if (method_ordering() != NULL) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3239 Array<int>* method_ordering = this->method_ordering();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3240 int length = method_ordering->length();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3241 if (JvmtiExport::can_maintain_original_method_order() \|\|
9057 8554c55669b0 8010943: guarantee(length == 0) failed: invalid method ordering length hseigel parents: 8719 diff changeset	3242 ((UseSharedSpaces \|\| DumpSharedSpaces) && length != 0)) {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3243 guarantee(length == methods()->length(), "invalid method ordering length");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3244 jlong sum = 0;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3245 for (int j = 0; j < length; j++) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3246 int original_index = method_ordering->at(j);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3247 guarantee(original_index >= 0, "invalid method ordering index");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3248 guarantee(original_index < length, "invalid method ordering index");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3249 sum += original_index;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3250 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3251 // Verify sum of indices 0,1,...,length-1
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3252 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	3253 } else {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3254 guarantee(length == 0, "invalid method ordering length");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3255 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3256 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3257
12823 ac9cb1d5a202 8009130: Lambda: Fix access controls, loader constraints. acorn parents: 12811 diff changeset	3258 // Verify default methods
ac9cb1d5a202 8009130: Lambda: Fix access controls, loader constraints. acorn parents: 12811 diff changeset	3259 if (default_methods() != NULL) {
ac9cb1d5a202 8009130: Lambda: Fix access controls, loader constraints. acorn parents: 12811 diff changeset	3260 Array<Method> methods = this->default_methods();
ac9cb1d5a202 8009130: Lambda: Fix access controls, loader constraints. acorn parents: 12811 diff changeset	3261 for (int j = 0; j < methods->length(); j++) {
ac9cb1d5a202 8009130: Lambda: Fix access controls, loader constraints. acorn parents: 12811 diff changeset	3262 guarantee(methods->at(j)->is_method(), "non-method in methods array");
ac9cb1d5a202 8009130: Lambda: Fix access controls, loader constraints. acorn parents: 12811 diff changeset	3263 }
ac9cb1d5a202 8009130: Lambda: Fix access controls, loader constraints. acorn parents: 12811 diff changeset	3264 for (int j = 0; j < methods->length() - 1; j++) {
ac9cb1d5a202 8009130: Lambda: Fix access controls, loader constraints. acorn parents: 12811 diff changeset	3265 Method* m1 = methods->at(j);
ac9cb1d5a202 8009130: Lambda: Fix access controls, loader constraints. acorn parents: 12811 diff changeset	3266 Method* m2 = methods->at(j + 1);
ac9cb1d5a202 8009130: Lambda: Fix access controls, loader constraints. acorn parents: 12811 diff changeset	3267 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	3268 }
ac9cb1d5a202 8009130: Lambda: Fix access controls, loader constraints. acorn parents: 12811 diff changeset	3269 }
ac9cb1d5a202 8009130: Lambda: Fix access controls, loader constraints. acorn parents: 12811 diff changeset	3270
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3271 // Verify JNI static field identifiers
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3272 if (jni_ids() != NULL) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3273 jni_ids()->verify(this);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3274 }
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 other fields
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3277 if (array_klasses() != NULL) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3278 guarantee(array_klasses()->is_klass(), "should be klass");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3279 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3280 if (constants() != NULL) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3281 guarantee(constants()->is_constantPool(), "should be constant pool");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3282 }
8693 872b3feace55 8008750: [partfait] Null pointer deference in hotspot/src/share/vm/oops/instanceKlass.hpp morris parents: 8031 diff changeset	3283 const Klass* host = host_klass();
872b3feace55 8008750: [partfait] Null pointer deference in hotspot/src/share/vm/oops/instanceKlass.hpp morris parents: 8031 diff changeset	3284 if (host != NULL) {
872b3feace55 8008750: [partfait] Null pointer deference in hotspot/src/share/vm/oops/instanceKlass.hpp morris parents: 8031 diff changeset	3285 guarantee(host->is_klass(), "should be klass");
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3286 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3287 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3288
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3289 void InstanceKlass::oop_verify_on(oop obj, outputStream* st) {
0 a61af66fc99e Initial load duke parents: diff changeset	3290 Klass::oop_verify_on(obj, st);
a61af66fc99e Initial load duke parents: diff changeset	3291 VerifyFieldClosure blk;
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3292 obj->oop_iterate_no_header(&blk);
0 a61af66fc99e Initial load duke parents: diff changeset	3293 }
a61af66fc99e Initial load duke parents: diff changeset	3294
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3295
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	3296 // JNIid class for jfieldIDs only
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	3297 // Note to reviewers:
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	3298 // 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	3299 // in the compressed oops workspace.
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3300 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	3301 _holder = holder;
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	3302 _offset = offset;
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	3303 _next = next;
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	3304 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	3305 }
0 a61af66fc99e Initial load duke parents: diff changeset	3306
a61af66fc99e Initial load duke parents: diff changeset	3307
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	3308 JNIid* JNIid::find(int offset) {
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	3309 JNIid* current = this;
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	3310 while (current != NULL) {
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	3311 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	3312 current = current->next();
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	3313 }
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	3314 return NULL;
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	3315 }
0 a61af66fc99e Initial load duke parents: diff changeset	3316
a61af66fc99e Initial load duke parents: diff changeset	3317 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	3318 while (current != NULL) {
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	3319 JNIid* next = current->next();
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	3320 delete current;
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	3321 current = next;
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	3322 }
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	3323 }
0 a61af66fc99e Initial load duke parents: diff changeset	3324
a61af66fc99e Initial load duke parents: diff changeset	3325
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3326 void JNIid::verify(Klass* holder) {
6735 aed758eda82a 7195833: NPG: Rename instanceClassLoaderKlass, instanceRefKlass and instanceMirrorKlass coleenp parents: 6733 diff changeset	3327 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	3328 int end_field_offset;
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3329 end_field_offset = first_field_offset + (InstanceKlass::cast(holder)->static_field_size() * wordSize);
0 a61af66fc99e Initial load duke parents: diff changeset	3330
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	3331 JNIid* current = this;
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	3332 while (current != NULL) {
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	3333 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	3334 #ifdef ASSERT
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	3335 int o = current->offset();
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	3336 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	3337 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	3338 }
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	3339 #endif
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	3340 current = current->next();
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	3341 }
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	3342 }
0 a61af66fc99e Initial load duke parents: diff changeset	3343
a61af66fc99e Initial load duke parents: diff changeset	3344
a61af66fc99e Initial load duke parents: diff changeset	3345 #ifdef ASSERT
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3346 void InstanceKlass::set_init_state(ClassState state) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3347 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	3348 : (_init_state < state);
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	3349 assert(good_state \|\| state == allocated, "illegal state transition");
4739 52b5d32fbfaf 7117052: instanceKlass::_init_state can be u1 type coleenp parents: 4006 diff changeset	3350 _init_state = (u1)state;
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 52 diff changeset	3351 }
0 a61af66fc99e Initial load duke parents: diff changeset	3352 #endif
a61af66fc99e Initial load duke parents: diff changeset	3353
a61af66fc99e Initial load duke parents: diff changeset	3354
a61af66fc99e Initial load duke parents: diff changeset	3355 // RedefineClasses() support for previous versions:
a61af66fc99e Initial load duke parents: diff changeset	3356
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3357 // Purge previous versions
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3358 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	3359 if (ik->previous_versions() != NULL) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3360 // 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	3361 // while it is safe to do so.
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3362
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3363 int deleted_count = 0; // leave debugging breadcrumbs
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3364 int live_count = 0;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3365 ClassLoaderData* loader_data = ik->class_loader_data() == NULL ?
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3366 ClassLoaderData::the_null_class_loader_data() :
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3367 ik->class_loader_data();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3368
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3369 // RC_TRACE macro has an embedded ResourceMark
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3370 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	3371 ik->external_name(), ik->previous_versions()->length()));
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3372
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3373 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	3374 // check the previous versions array
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3375 PreviousVersionNode * pv_node = ik->previous_versions()->at(i);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3376 ConstantPool* cp_ref = pv_node->prev_constant_pool();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3377 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	3378
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3379 ConstantPool* pvcp = cp_ref;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3380 if (!pvcp->on_stack()) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3381 // 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	3382 // 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	3383 // and this previous version node.
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3384 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	3385 if (method_refs != NULL) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3386 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	3387 Method* method = method_refs->at(j);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3388 assert(method != NULL, "method ref was unexpectedly cleared");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3389 method_refs->remove_at(j);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3390 // method will be freed with associated class.
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3391 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3392 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3393 // Remove the constant pool
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3394 delete pv_node;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3395 // 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	3396 // do anything special with the index.
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3397 ik->previous_versions()->remove_at(i);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3398 deleted_count++;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3399 continue;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3400 } else {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3401 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	3402 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	3403 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	3404 live_count++;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3405 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3406
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3407 // 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	3408 // the others or mark them as obsolete.
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 RC_TRACE(0x00000200, ("purge: previous methods length=%d",
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3412 method_refs->length()));
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3413 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	3414 Method* method = method_refs->at(j);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3415 assert(method != NULL, "method ref was unexpectedly cleared");
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 // 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	3418 // 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	3419 // 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	3420 if (!method->on_stack()) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3421 method_refs->remove_at(j);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3422 } else if (emcp_method_count == 0) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3423 method->set_is_obsolete();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3424 } else {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3425 // RC_TRACE macro has an embedded ResourceMark
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3426 RC_TRACE(0x00000200,
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3427 ("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	3428 method->name()->as_C_string(),
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3429 method->signature()->as_C_string(), j, i));
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 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3433 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3434 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	3435 RC_TRACE(0x00000200,
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3436 ("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	3437 deleted_count));
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3438 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3439 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3440
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3441 // External interface for use during class unloading.
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3442 void InstanceKlass::purge_previous_versions(InstanceKlass* ik) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3443 // 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	3444 purge_previous_versions_internal(ik, 1);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3445 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3446
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3447
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3448 // Potentially add an information node that contains pointers to the
0 a61af66fc99e Initial load duke parents: diff changeset	3449 // 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	3450 // 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	3451 // 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	3452 // 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	3453 // 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	3454 //
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3455 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	3456 BitMap* emcp_methods, int emcp_method_count) {
0 a61af66fc99e Initial load duke parents: diff changeset	3457 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	3458 "only VMThread can add previous versions");
0 a61af66fc99e Initial load duke parents: diff changeset	3459
a61af66fc99e Initial load duke parents: diff changeset	3460 if (_previous_versions == NULL) {
a61af66fc99e Initial load duke parents: diff changeset	3461 // This is the first previous version so make some space.
a61af66fc99e Initial load duke parents: diff changeset	3462 // Start with 2 elements under the assumption that the class
a61af66fc99e Initial load duke parents: diff changeset	3463 // won't be redefined much.
6197 d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: 6038 diff changeset	3464 _previous_versions = new (ResourceObj::C_HEAP, mtClass)
0 a61af66fc99e Initial load duke parents: diff changeset	3465 GrowableArray<PreviousVersionNode *>(2, true);
a61af66fc99e Initial load duke parents: diff changeset	3466 }
a61af66fc99e Initial load duke parents: diff changeset	3467
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3468 ConstantPool* cp_ref = ikh->constants();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3469
0 a61af66fc99e Initial load duke parents: diff changeset	3470 // RC_TRACE macro has an embedded ResourceMark
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3471 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	3472 "on_stack=%d",
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3473 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	3474 cp_ref->on_stack()));
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3475
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3476 // 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	3477 // 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	3478 // 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	3479 // 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	3480 // 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	3481 Array<Method> old_methods = ikh->methods();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3482
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3483 if (cp_ref->on_stack()) {
12281 4f9a42c33738 8022887: Assertion hit while using class and redefining it with RedefineClasses simultaneously coleenp parents: 12067 diff changeset	3484 PreviousVersionNode * pv_node = NULL;
4f9a42c33738 8022887: Assertion hit while using class and redefining it with RedefineClasses simultaneously coleenp parents: 12067 diff changeset	3485 if (emcp_method_count == 0) {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3486 // 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	3487 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	3488 RC_TRACE(0x00000400,
4f9a42c33738 8022887: Assertion hit while using class and redefining it with RedefineClasses simultaneously coleenp parents: 12067 diff changeset	3489 ("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	3490 } else {
4f9a42c33738 8022887: Assertion hit while using class and redefining it with RedefineClasses simultaneously coleenp parents: 12067 diff changeset	3491 int local_count = 0;
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3492 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	3493 GrowableArray<Method*>(emcp_method_count, true);
4f9a42c33738 8022887: Assertion hit while using class and redefining it with RedefineClasses simultaneously coleenp parents: 12067 diff changeset	3494 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	3495 if (emcp_methods->at(i)) {
4f9a42c33738 8022887: Assertion hit while using class and redefining it with RedefineClasses simultaneously coleenp parents: 12067 diff changeset	3496 // 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	3497 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	3498 if (old_method->on_stack()) {
4f9a42c33738 8022887: Assertion hit while using class and redefining it with RedefineClasses simultaneously coleenp parents: 12067 diff changeset	3499 method_refs->append(old_method);
4f9a42c33738 8022887: Assertion hit while using class and redefining it with RedefineClasses simultaneously coleenp parents: 12067 diff changeset	3500 }
4f9a42c33738 8022887: Assertion hit while using class and redefining it with RedefineClasses simultaneously coleenp parents: 12067 diff changeset	3501 if (++local_count >= emcp_method_count) {
4f9a42c33738 8022887: Assertion hit while using class and redefining it with RedefineClasses simultaneously coleenp parents: 12067 diff changeset	3502 // 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	3503 break;
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3504 }
0 a61af66fc99e Initial load duke parents: diff changeset	3505 }
a61af66fc99e Initial load duke parents: diff changeset	3506 }
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3507 // 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	3508 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	3509 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3510 // append new previous version.
12281 4f9a42c33738 8022887: Assertion hit while using class and redefining it with RedefineClasses simultaneously coleenp parents: 12067 diff changeset	3511 _previous_versions->append(pv_node);
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3512 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3513
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3514 // 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	3515 // is a good time to clear out unused references.
0 a61af66fc99e Initial load duke parents: diff changeset	3516
a61af66fc99e Initial load duke parents: diff changeset	3517 RC_TRACE(0x00000400, ("add: previous version length=%d",
a61af66fc99e Initial load duke parents: diff changeset	3518 _previous_versions->length()));
a61af66fc99e Initial load duke parents: diff changeset	3519
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3520 // Purge previous versions not executing on the stack
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3521 purge_previous_versions_internal(this, emcp_method_count);
0 a61af66fc99e Initial load duke parents: diff changeset	3522
a61af66fc99e Initial load duke parents: diff changeset	3523 int obsolete_method_count = old_methods->length() - emcp_method_count;
a61af66fc99e Initial load duke parents: diff changeset	3524
a61af66fc99e Initial load duke parents: diff changeset	3525 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	3526 _previous_versions->length() > 0) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3527 // We have a mix of obsolete and EMCP methods so we have to
0 a61af66fc99e Initial load duke parents: diff changeset	3528 // clear out any matching EMCP method entries the hard way.
a61af66fc99e Initial load duke parents: diff changeset	3529 int local_count = 0;
a61af66fc99e Initial load duke parents: diff changeset	3530 for (int i = 0; i < old_methods->length(); i++) {
a61af66fc99e Initial load duke parents: diff changeset	3531 if (!emcp_methods->at(i)) {
a61af66fc99e Initial load duke parents: diff changeset	3532 // only obsolete methods are interesting
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3533 Method* old_method = old_methods->at(i);
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	3534 Symbol* m_name = old_method->name();
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	3535 Symbol* m_signature = old_method->signature();
0 a61af66fc99e Initial load duke parents: diff changeset	3536
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3537 // we might not have added the last entry
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3538 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	3539 // 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	3540 PreviousVersionNode * pv_node = _previous_versions->at(j);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3541
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3542 GrowableArray<Method> method_refs = pv_node->prev_EMCP_methods();
0 a61af66fc99e Initial load duke parents: diff changeset	3543 if (method_refs == NULL) {
a61af66fc99e Initial load duke parents: diff changeset	3544 // We have run into a PreviousVersion generation where
a61af66fc99e Initial load duke parents: diff changeset	3545 // all methods were made obsolete during that generation's
a61af66fc99e Initial load duke parents: diff changeset	3546 // RedefineClasses() operation. At the time of that
a61af66fc99e Initial load duke parents: diff changeset	3547 // operation, all EMCP methods were flushed so we don't
a61af66fc99e Initial load duke parents: diff changeset	3548 // have to go back any further.
a61af66fc99e Initial load duke parents: diff changeset	3549 //
a61af66fc99e Initial load duke parents: diff changeset	3550 // A NULL method_refs is different than an empty method_refs.
a61af66fc99e Initial load duke parents: diff changeset	3551 // We cannot infer any optimizations about older generations
a61af66fc99e Initial load duke parents: diff changeset	3552 // from an empty method_refs for the current generation.
a61af66fc99e Initial load duke parents: diff changeset	3553 break;
a61af66fc99e Initial load duke parents: diff changeset	3554 }
a61af66fc99e Initial load duke parents: diff changeset	3555
a61af66fc99e Initial load duke parents: diff changeset	3556 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	3557 Method* method = method_refs->at(k);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3558
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3559 if (!method->is_obsolete() &&
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3560 method->name() == m_name &&
0 a61af66fc99e Initial load duke parents: diff changeset	3561 method->signature() == m_signature) {
a61af66fc99e Initial load duke parents: diff changeset	3562 // The current RedefineClasses() call has made all EMCP
a61af66fc99e Initial load duke parents: diff changeset	3563 // 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	3564 // and remove the reference.
0 a61af66fc99e Initial load duke parents: diff changeset	3565 RC_TRACE(0x00000400,
a61af66fc99e Initial load duke parents: diff changeset	3566 ("add: %s(%s): flush obsolete method @%d in version @%d",
a61af66fc99e Initial load duke parents: diff changeset	3567 m_name->as_C_string(), m_signature->as_C_string(), k, j));
a61af66fc99e Initial load duke parents: diff changeset	3568
a61af66fc99e Initial load duke parents: diff changeset	3569 method->set_is_obsolete();
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3570 // 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	3571 // clean up later.
0 a61af66fc99e Initial load duke parents: diff changeset	3572 break;
a61af66fc99e Initial load duke parents: diff changeset	3573 }
a61af66fc99e Initial load duke parents: diff changeset	3574 }
a61af66fc99e Initial load duke parents: diff changeset	3575
a61af66fc99e Initial load duke parents: diff changeset	3576 // The previous loop may not find a matching EMCP method, but
a61af66fc99e Initial load duke parents: diff changeset	3577 // that doesn't mean that we can optimize and not go any
a61af66fc99e Initial load duke parents: diff changeset	3578 // 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	3579 // method for this generation could have already been deleted,
0 a61af66fc99e Initial load duke parents: diff changeset	3580 // 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	3581 // been deleted.
0 a61af66fc99e Initial load duke parents: diff changeset	3582 }
a61af66fc99e Initial load duke parents: diff changeset	3583
a61af66fc99e Initial load duke parents: diff changeset	3584 if (++local_count >= obsolete_method_count) {
a61af66fc99e Initial load duke parents: diff changeset	3585 // no more obsolete methods so bail out now
a61af66fc99e Initial load duke parents: diff changeset	3586 break;
a61af66fc99e Initial load duke parents: diff changeset	3587 }
a61af66fc99e Initial load duke parents: diff changeset	3588 }
a61af66fc99e Initial load duke parents: diff changeset	3589 }
a61af66fc99e Initial load duke parents: diff changeset	3590 }
a61af66fc99e Initial load duke parents: diff changeset	3591 } // end add_previous_version()
a61af66fc99e Initial load duke parents: diff changeset	3592
a61af66fc99e Initial load duke parents: diff changeset	3593
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3594 // Determine if InstanceKlass has a previous version.
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3595 bool InstanceKlass::has_previous_version() const {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3596 return (_previous_versions != NULL && _previous_versions->length() > 0);
0 a61af66fc99e Initial load duke parents: diff changeset	3597 } // end has_previous_version()
a61af66fc99e Initial load duke parents: diff changeset	3598
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3599
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3600 Method* InstanceKlass::method_with_idnum(int idnum) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3601 Method* m = NULL;
0 a61af66fc99e Initial load duke parents: diff changeset	3602 if (idnum < methods()->length()) {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3603 m = methods()->at(idnum);
0 a61af66fc99e Initial load duke parents: diff changeset	3604 }
a61af66fc99e Initial load duke parents: diff changeset	3605 if (m == NULL \|\| m->method_idnum() != idnum) {
a61af66fc99e Initial load duke parents: diff changeset	3606 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	3607 m = methods()->at(index);
0 a61af66fc99e Initial load duke parents: diff changeset	3608 if (m->method_idnum() == idnum) {
a61af66fc99e Initial load duke parents: diff changeset	3609 return m;
a61af66fc99e Initial load duke parents: diff changeset	3610 }
a61af66fc99e Initial load duke parents: diff changeset	3611 }
12281 4f9a42c33738 8022887: Assertion hit while using class and redefining it with RedefineClasses simultaneously coleenp parents: 12067 diff changeset	3612 // 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	3613 return NULL;
0 a61af66fc99e Initial load duke parents: diff changeset	3614 }
a61af66fc99e Initial load duke parents: diff changeset	3615 return m;
a61af66fc99e Initial load duke parents: diff changeset	3616 }
a61af66fc99e Initial load duke parents: diff changeset	3617
11148 825e6cb66923 8020309: Eliminate InstanceKlass::_cached_class_file_len. jiangli parents: 11096 diff changeset	3618 jint InstanceKlass::get_cached_class_file_len() {
825e6cb66923 8020309: Eliminate InstanceKlass::_cached_class_file_len. jiangli parents: 11096 diff changeset	3619 return VM_RedefineClasses::get_cached_class_file_len(_cached_class_file);
825e6cb66923 8020309: Eliminate InstanceKlass::_cached_class_file_len. jiangli parents: 11096 diff changeset	3620 }
825e6cb66923 8020309: Eliminate InstanceKlass::_cached_class_file_len. jiangli parents: 11096 diff changeset	3621
825e6cb66923 8020309: Eliminate InstanceKlass::_cached_class_file_len. jiangli parents: 11096 diff changeset	3622 unsigned char * InstanceKlass::get_cached_class_file_bytes() {
825e6cb66923 8020309: Eliminate InstanceKlass::_cached_class_file_len. jiangli parents: 11096 diff changeset	3623 return VM_RedefineClasses::get_cached_class_file_bytes(_cached_class_file);
825e6cb66923 8020309: Eliminate InstanceKlass::_cached_class_file_len. jiangli parents: 11096 diff changeset	3624 }
825e6cb66923 8020309: Eliminate InstanceKlass::_cached_class_file_len. jiangli parents: 11096 diff changeset	3625
0 a61af66fc99e Initial load duke parents: diff changeset	3626
a61af66fc99e Initial load duke parents: diff changeset	3627 // 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	3628 // the InstanceKlass.
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3629 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	3630 GrowableArray<Method> prev_EMCP_methods) {
0 a61af66fc99e Initial load duke parents: diff changeset	3631
a61af66fc99e Initial load duke parents: diff changeset	3632 _prev_constant_pool = prev_constant_pool;
a61af66fc99e Initial load duke parents: diff changeset	3633 _prev_EMCP_methods = prev_EMCP_methods;
a61af66fc99e Initial load duke parents: diff changeset	3634 }
a61af66fc99e Initial load duke parents: diff changeset	3635
a61af66fc99e Initial load duke parents: diff changeset	3636
a61af66fc99e Initial load duke parents: diff changeset	3637 // Destroy a PreviousVersionNode
a61af66fc99e Initial load duke parents: diff changeset	3638 PreviousVersionNode::~PreviousVersionNode() {
a61af66fc99e Initial load duke parents: diff changeset	3639 if (_prev_constant_pool != NULL) {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	3640 _prev_constant_pool = NULL;
0 a61af66fc99e Initial load duke parents: diff changeset	3641 }
a61af66fc99e Initial load duke parents: diff changeset	3642
a61af66fc99e Initial load duke parents: diff changeset	3643 if (_prev_EMCP_methods != NULL) {
a61af66fc99e Initial load duke parents: diff changeset	3644 delete _prev_EMCP_methods;
a61af66fc99e Initial load duke parents: diff changeset	3645 }
a61af66fc99e Initial load duke parents: diff changeset	3646 }
a61af66fc99e Initial load duke parents: diff changeset	3647
a61af66fc99e Initial load duke parents: diff changeset	3648 // 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	3649 PreviousVersionWalker::PreviousVersionWalker(Thread* thread, InstanceKlass *ik) {
4f9a42c33738 8022887: Assertion hit while using class and redefining it with RedefineClasses simultaneously coleenp parents: 12067 diff changeset	3650 _thread = thread;
0 a61af66fc99e Initial load duke parents: diff changeset	3651 _previous_versions = ik->previous_versions();
a61af66fc99e Initial load duke parents: diff changeset	3652 _current_index = 0;
a61af66fc99e Initial load duke parents: diff changeset	3653 _current_p = NULL;
12281 4f9a42c33738 8022887: Assertion hit while using class and redefining it with RedefineClasses simultaneously coleenp parents: 12067 diff changeset	3654 _current_constant_pool_handle = constantPoolHandle(thread, ik->constants());
0 a61af66fc99e Initial load duke parents: diff changeset	3655 }
a61af66fc99e Initial load duke parents: diff changeset	3656
a61af66fc99e Initial load duke parents: diff changeset	3657
a61af66fc99e Initial load duke parents: diff changeset	3658 // Return the interesting information for the next previous version
a61af66fc99e Initial load duke parents: diff changeset	3659 // 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	3660 PreviousVersionNode* PreviousVersionWalker::next_previous_version() {
0 a61af66fc99e Initial load duke parents: diff changeset	3661 if (_previous_versions == NULL) {
a61af66fc99e Initial load duke parents: diff changeset	3662 // no previous versions so nothing to return
a61af66fc99e Initial load duke parents: diff changeset	3663 return NULL;
a61af66fc99e Initial load duke parents: diff changeset	3664 }
a61af66fc99e Initial load duke parents: diff changeset	3665
12281 4f9a42c33738 8022887: Assertion hit while using class and redefining it with RedefineClasses simultaneously coleenp parents: 12067 diff changeset	3666 _current_p = NULL; // reset to NULL
4f9a42c33738 8022887: Assertion hit while using class and redefining it with RedefineClasses simultaneously coleenp parents: 12067 diff changeset	3667 _current_constant_pool_handle = NULL;
0 a61af66fc99e Initial load duke parents: diff changeset	3668
a61af66fc99e Initial load duke parents: diff changeset	3669 int length = _previous_versions->length();
a61af66fc99e Initial load duke parents: diff changeset	3670
a61af66fc99e Initial load duke parents: diff changeset	3671 while (_current_index < length) {
a61af66fc99e Initial load duke parents: diff changeset	3672 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	3673
4f9a42c33738 8022887: Assertion hit while using class and redefining it with RedefineClasses simultaneously coleenp parents: 12067 diff changeset	3674 // 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	3675 // 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	3676 _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	3677 _current_p = pv_node;
4f9a42c33738 8022887: Assertion hit while using class and redefining it with RedefineClasses simultaneously coleenp parents: 12067 diff changeset	3678 return pv_node;
0 a61af66fc99e Initial load duke parents: diff changeset	3679 }
a61af66fc99e Initial load duke parents: diff changeset	3680
a61af66fc99e Initial load duke parents: diff changeset	3681 return NULL;
a61af66fc99e Initial load duke parents: diff changeset	3682 } // end next_previous_version()

Mercurial > hg > truffle

annotate src/share/vm/oops/instanceKlass.cpp @ 13212:eb03a7335eb0