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

annotate src/share/vm/oops/instanceKlass.cpp @ 18041:52b4284cb496

Merge with jdk8u20-b26

author	Gilles Duboscq <duboscq@ssw.jku.at>
date	Wed, 15 Oct 2014 16:02:50 +0200
parents	89152779163c bd4d69d9cb7d
children	e6637891a870

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

Mercurial > hg > truffle

annotate src/share/vm/oops/instanceKlass.cpp @ 18041:52b4284cb496