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

annotate src/share/vm/oops/instanceKlass.cpp @ 17524:89152779163c

Merge with jdk8-b132

author	Gilles Duboscq <duboscq@ssw.jku.at>
date	Wed, 15 Oct 2014 11:59:32 +0200
parents	ad431bf0de07
children	52b4284cb496

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

Mercurial > hg > truffle

annotate src/share/vm/oops/instanceKlass.cpp @ 17524:89152779163c