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

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

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

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

rev	line source
0 a61af66fc99e Initial load duke parents: diff changeset	1 /*
7624 b14da2e6f2dc 7174978: NPG: Fix bactrace builder for class redefinition coleenp parents: 7185 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: 1142 diff changeset	19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
c18cbe5936b8 6941466: Oracle rebranding changes for Hotspot repositories trims parents: 1142 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: 1142 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: 1913 diff changeset	25 #include "precompiled.hpp"
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	26 #include "classfile/classLoaderData.hpp"
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1913 diff changeset	27 #include "classfile/javaClasses.hpp"
7949 5daaddd917a1 8006040: NPG: on_stack processing wastes space in ConstantPool coleenp parents: 7624 diff changeset	28 #include "classfile/metadataOnStackMark.hpp"
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1913 diff changeset	29 #include "classfile/symbolTable.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1913 diff changeset	30 #include "classfile/systemDictionary.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1913 diff changeset	31 #include "classfile/vmSymbols.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1913 diff changeset	32 #include "interpreter/linkResolver.hpp"
7956 16fb9f942703 6479360: PrintClassHistogram improvements acorn parents: 7949 diff changeset	33 #include "memory/heapInspection.hpp"
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	34 #include "memory/metadataFactory.hpp"
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1913 diff changeset	35 #include "memory/oopFactory.hpp"
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	36 #include "oops/constantPool.hpp"
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1913 diff changeset	37 #include "oops/instanceKlass.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1913 diff changeset	38 #include "oops/objArrayKlass.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1913 diff changeset	39 #include "runtime/fieldType.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1913 diff changeset	40 #include "runtime/init.hpp"
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	41 #include "runtime/javaCalls.hpp"
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1913 diff changeset	42 #include "runtime/signature.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1913 diff changeset	43 #include "runtime/vframe.hpp"
0 a61af66fc99e Initial load duke parents: diff changeset	44
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	45 ConstantPool* ConstantPool::allocate(ClassLoaderData* loader_data, int length, TRAPS) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	46 // Tags are RW but comment below applies to tags also.
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	47 Array<u1>* tags = MetadataFactory::new_writeable_array<u1>(loader_data, length, 0, CHECK_NULL);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	48
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	49 int size = ConstantPool::size(length);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	50
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	51 // CDS considerations:
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	52 // Allocate read-write but may be able to move to read-only at dumping time
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	53 // if all the klasses are resolved. The only other field that is writable is
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	54 // the resolved_references array, which is recreated at startup time.
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	55 // But that could be moved to InstanceKlass (although a pain to access from
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	56 // assembly code). Maybe it could be moved to the cpCache which is RW.
10376 a1ebd310d5c1 8014912: Restore PrintSharedSpaces functionality after NPG iklam parents: 10350 diff changeset	57 return new (loader_data, size, false, MetaspaceObj::ConstantPoolType, THREAD) ConstantPool(tags);
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	58 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	59
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	60 ConstantPool::ConstantPool(Array<u1>* tags) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	61 set_length(tags->length());
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	62 set_tags(NULL);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	63 set_cache(NULL);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	64 set_reference_map(NULL);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	65 set_resolved_references(NULL);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	66 set_operands(NULL);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	67 set_pool_holder(NULL);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	68 set_flags(0);
7949 5daaddd917a1 8006040: NPG: on_stack processing wastes space in ConstantPool coleenp parents: 7624 diff changeset	69
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	70 // only set to non-zero if constant pool is merged by RedefineClasses
7624 b14da2e6f2dc 7174978: NPG: Fix bactrace builder for class redefinition coleenp parents: 7185 diff changeset	71 set_version(0);
12946 b8860472c377 8014910: deadlock between JVM/TI ClassPrepare event handler and CompilerThread iklam parents: 12850 diff changeset	72 set_lock(new Monitor(Monitor::nonleaf + 2, "A constant pool lock"));
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	73
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	74 // initialize tag array
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	75 int length = tags->length();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	76 for (int index = 0; index < length; index++) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	77 tags->at_put(index, JVM_CONSTANT_Invalid);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	78 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	79 set_tags(tags);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	80 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	81
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	82 void ConstantPool::deallocate_contents(ClassLoaderData* loader_data) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	83 MetadataFactory::free_metadata(loader_data, cache());
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	84 set_cache(NULL);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	85 MetadataFactory::free_array<jushort>(loader_data, operands());
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	86 set_operands(NULL);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	87
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	88 release_C_heap_structures();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	89
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	90 // free tag array
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	91 MetadataFactory::free_array<u1>(loader_data, tags());
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	92 set_tags(NULL);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	93 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	94
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	95 void ConstantPool::release_C_heap_structures() {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	96 // walk constant pool and decrement symbol reference counts
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	97 unreference_symbols();
12946 b8860472c377 8014910: deadlock between JVM/TI ClassPrepare event handler and CompilerThread iklam parents: 12850 diff changeset	98
b8860472c377 8014910: deadlock between JVM/TI ClassPrepare event handler and CompilerThread iklam parents: 12850 diff changeset	99 delete _lock;
b8860472c377 8014910: deadlock between JVM/TI ClassPrepare event handler and CompilerThread iklam parents: 12850 diff changeset	100 set_lock(NULL);
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	101 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	102
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	103 objArrayOop ConstantPool::resolved_references() const {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	104 return (objArrayOop)JNIHandles::resolve(_resolved_references);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	105 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	106
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	107 // Create resolved_references array and mapping array for original cp indexes
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	108 // The ldc bytecode was rewritten to have the resolved reference array index so need a way
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	109 // to map it back for resolving and some unlikely miscellaneous uses.
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	110 // The objects created by invokedynamic are appended to this list.
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	111 void ConstantPool::initialize_resolved_references(ClassLoaderData* loader_data,
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	112 intStack reference_map,
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	113 int constant_pool_map_length,
12285 7c29904fdfa2 8014956: nashorn/api/javaaccess/MethodAccessTest.java test fails on sparc-solaris 64 coleenp parents: 11034 diff changeset	114 TRAPS) {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	115 // Initialized the resolved object cache.
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	116 int map_length = reference_map.length();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	117 if (map_length > 0) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	118 // Only need mapping back to constant pool entries. The map isn't used for
12285 7c29904fdfa2 8014956: nashorn/api/javaaccess/MethodAccessTest.java test fails on sparc-solaris 64 coleenp parents: 11034 diff changeset	119 // invokedynamic resolved_reference entries. For invokedynamic entries,
7c29904fdfa2 8014956: nashorn/api/javaaccess/MethodAccessTest.java test fails on sparc-solaris 64 coleenp parents: 11034 diff changeset	120 // the constant pool cache index has the mapping back to both the constant
7c29904fdfa2 8014956: nashorn/api/javaaccess/MethodAccessTest.java test fails on sparc-solaris 64 coleenp parents: 11034 diff changeset	121 // pool and to the resolved reference index.
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	122 if (constant_pool_map_length > 0) {
12285 7c29904fdfa2 8014956: nashorn/api/javaaccess/MethodAccessTest.java test fails on sparc-solaris 64 coleenp parents: 11034 diff changeset	123 Array<u2>* om = MetadataFactory::new_array<u2>(loader_data, constant_pool_map_length, CHECK);
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	124
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	125 for (int i = 0; i < constant_pool_map_length; i++) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	126 int x = reference_map.at(i);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	127 assert(x == (int)(jushort) x, "klass index is too big");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	128 om->at_put(i, (jushort)x);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	129 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	130 set_reference_map(om);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	131 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	132
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	133 // Create Java array for holding resolved strings, methodHandles,
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	134 // methodTypes, invokedynamic and invokehandle appendix objects, etc.
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	135 objArrayOop stom = oopFactory::new_objArray(SystemDictionary::Object_klass(), map_length, CHECK);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	136 Handle refs_handle (THREAD, (oop)stom); // must handleize.
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	137 set_resolved_references(loader_data->add_handle(refs_handle));
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	138 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	139 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	140
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	141 // CDS support. Create a new resolved_references array.
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	142 void ConstantPool::restore_unshareable_info(TRAPS) {
6733 fa6e618671d7 7195867: NPG: SAJDI tests fail with sun.jvm.hotspot.types.WrongTypeException: No suitable match for type coleenp parents: 6725 diff changeset	143
fa6e618671d7 7195867: NPG: SAJDI tests fail with sun.jvm.hotspot.types.WrongTypeException: No suitable match for type coleenp parents: 6725 diff changeset	144 // restore the C++ vtable from the shared archive
fa6e618671d7 7195867: NPG: SAJDI tests fail with sun.jvm.hotspot.types.WrongTypeException: No suitable match for type coleenp parents: 6725 diff changeset	145 restore_vtable();
fa6e618671d7 7195867: NPG: SAJDI tests fail with sun.jvm.hotspot.types.WrongTypeException: No suitable match for type coleenp parents: 6725 diff changeset	146
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	147 if (SystemDictionary::Object_klass_loaded()) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	148 // Recreate the object array and add to ClassLoaderData.
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	149 int map_length = resolved_reference_length();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	150 if (map_length > 0) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	151 objArrayOop stom = oopFactory::new_objArray(SystemDictionary::Object_klass(), map_length, CHECK);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	152 Handle refs_handle (THREAD, (oop)stom); // must handleize.
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	153
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	154 ClassLoaderData* loader_data = pool_holder()->class_loader_data();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	155 set_resolved_references(loader_data->add_handle(refs_handle));
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	156 }
12946 b8860472c377 8014910: deadlock between JVM/TI ClassPrepare event handler and CompilerThread iklam parents: 12850 diff changeset	157
b8860472c377 8014910: deadlock between JVM/TI ClassPrepare event handler and CompilerThread iklam parents: 12850 diff changeset	158 // Also need to recreate the mutex. Make sure this matches the constructor
b8860472c377 8014910: deadlock between JVM/TI ClassPrepare event handler and CompilerThread iklam parents: 12850 diff changeset	159 set_lock(new Monitor(Monitor::nonleaf + 2, "A constant pool lock"));
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	160 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	161 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	162
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	163 void ConstantPool::remove_unshareable_info() {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	164 // Resolved references are not in the shared archive.
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	165 // Save the length for restoration. It is not necessarily the same length
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	166 // as reference_map.length() if invokedynamic is saved.
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	167 set_resolved_reference_length(
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	168 resolved_references() != NULL ? resolved_references()->length() : 0);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	169 set_resolved_references(NULL);
12946 b8860472c377 8014910: deadlock between JVM/TI ClassPrepare event handler and CompilerThread iklam parents: 12850 diff changeset	170 set_lock(NULL);
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	171 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	172
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	173 int ConstantPool::cp_to_object_index(int cp_index) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	174 // this is harder don't do this so much.
12285 7c29904fdfa2 8014956: nashorn/api/javaaccess/MethodAccessTest.java test fails on sparc-solaris 64 coleenp parents: 11034 diff changeset	175 int i = reference_map()->find(cp_index);
7c29904fdfa2 8014956: nashorn/api/javaaccess/MethodAccessTest.java test fails on sparc-solaris 64 coleenp parents: 11034 diff changeset	176 // We might not find the index for jsr292 call.
7c29904fdfa2 8014956: nashorn/api/javaaccess/MethodAccessTest.java test fails on sparc-solaris 64 coleenp parents: 11034 diff changeset	177 return (i < 0) ? _no_index_sentinel : i;
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	178 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	179
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	180 Klass* ConstantPool::klass_at_impl(constantPoolHandle this_oop, int which, TRAPS) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	181 // A resolved constantPool entry will contain a Klass, otherwise a Symbol.
0 a61af66fc99e Initial load duke parents: diff changeset	182 // It is not safe to rely on the tag bit's here, since we don't have a lock, and the entry and
a61af66fc99e Initial load duke parents: diff changeset	183 // tag is not updated atomicly.
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	184
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	185 CPSlot entry = this_oop->slot_at(which);
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	186 if (entry.is_resolved()) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	187 assert(entry.get_klass()->is_klass(), "must be");
0 a61af66fc99e Initial load duke parents: diff changeset	188 // Already resolved - return entry.
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	189 return entry.get_klass();
0 a61af66fc99e Initial load duke parents: diff changeset	190 }
a61af66fc99e Initial load duke parents: diff changeset	191
a61af66fc99e Initial load duke parents: diff changeset	192 // Acquire lock on constant oop while doing update. After we get the lock, we check if another object
a61af66fc99e Initial load duke parents: diff changeset	193 // already has updated the object
a61af66fc99e Initial load duke parents: diff changeset	194 assert(THREAD->is_Java_thread(), "must be a Java thread");
a61af66fc99e Initial load duke parents: diff changeset	195 bool do_resolve = false;
a61af66fc99e Initial load duke parents: diff changeset	196 bool in_error = false;
a61af66fc99e Initial load duke parents: diff changeset	197
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	198 // Create a handle for the mirror. This will preserve the resolved class
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	199 // until the loader_data is registered.
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	200 Handle mirror_handle;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	201
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	202 Symbol* name = NULL;
0 a61af66fc99e Initial load duke parents: diff changeset	203 Handle loader;
12946 b8860472c377 8014910: deadlock between JVM/TI ClassPrepare event handler and CompilerThread iklam parents: 12850 diff changeset	204 { MonitorLockerEx ml(this_oop->lock());
0 a61af66fc99e Initial load duke parents: diff changeset	205
a61af66fc99e Initial load duke parents: diff changeset	206 if (this_oop->tag_at(which).is_unresolved_klass()) {
a61af66fc99e Initial load duke parents: diff changeset	207 if (this_oop->tag_at(which).is_unresolved_klass_in_error()) {
a61af66fc99e Initial load duke parents: diff changeset	208 in_error = true;
a61af66fc99e Initial load duke parents: diff changeset	209 } else {
a61af66fc99e Initial load duke parents: diff changeset	210 do_resolve = true;
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	211 name = this_oop->unresolved_klass_at(which);
6940 18fb7da42534 8000725: NPG: method_holder() and pool_holder() and pool_holder field should be InstanceKlass coleenp parents: 6934 diff changeset	212 loader = Handle(THREAD, this_oop->pool_holder()->class_loader());
0 a61af66fc99e Initial load duke parents: diff changeset	213 }
a61af66fc99e Initial load duke parents: diff changeset	214 }
a61af66fc99e Initial load duke parents: diff changeset	215 } // unlocking constantPool
a61af66fc99e Initial load duke parents: diff changeset	216
a61af66fc99e Initial load duke parents: diff changeset	217
a61af66fc99e Initial load duke parents: diff changeset	218 // The original attempt to resolve this constant pool entry failed so find the
a61af66fc99e Initial load duke parents: diff changeset	219 // original error and throw it again (JVMS 5.4.3).
a61af66fc99e Initial load duke parents: diff changeset	220 if (in_error) {
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	221 Symbol* error = SystemDictionary::find_resolution_error(this_oop, which);
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	222 guarantee(error != (Symbol*)NULL, "tag mismatch with resolution error table");
0 a61af66fc99e Initial load duke parents: diff changeset	223 ResourceMark rm;
a61af66fc99e Initial load duke parents: diff changeset	224 // exception text will be the class name
a61af66fc99e Initial load duke parents: diff changeset	225 const char* className = this_oop->unresolved_klass_at(which)->as_C_string();
a61af66fc99e Initial load duke parents: diff changeset	226 THROW_MSG_0(error, className);
a61af66fc99e Initial load duke parents: diff changeset	227 }
a61af66fc99e Initial load duke parents: diff changeset	228
a61af66fc99e Initial load duke parents: diff changeset	229 if (do_resolve) {
a61af66fc99e Initial load duke parents: diff changeset	230 // this_oop must be unlocked during resolve_or_fail
6940 18fb7da42534 8000725: NPG: method_holder() and pool_holder() and pool_holder field should be InstanceKlass coleenp parents: 6934 diff changeset	231 oop protection_domain = this_oop->pool_holder()->protection_domain();
0 a61af66fc99e Initial load duke parents: diff changeset	232 Handle h_prot (THREAD, protection_domain);
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	233 Klass* k_oop = SystemDictionary::resolve_or_fail(name, loader, h_prot, true, THREAD);
0 a61af66fc99e Initial load duke parents: diff changeset	234 KlassHandle k;
a61af66fc99e Initial load duke parents: diff changeset	235 if (!HAS_PENDING_EXCEPTION) {
a61af66fc99e Initial load duke parents: diff changeset	236 k = KlassHandle(THREAD, k_oop);
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	237 // preserve the resolved klass.
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	238 mirror_handle = Handle(THREAD, k_oop->java_mirror());
0 a61af66fc99e Initial load duke parents: diff changeset	239 // Do access check for klasses
a61af66fc99e Initial load duke parents: diff changeset	240 verify_constant_pool_resolve(this_oop, k, THREAD);
a61af66fc99e Initial load duke parents: diff changeset	241 }
a61af66fc99e Initial load duke parents: diff changeset	242
a61af66fc99e Initial load duke parents: diff changeset	243 // Failed to resolve class. We must record the errors so that subsequent attempts
a61af66fc99e Initial load duke parents: diff changeset	244 // to resolve this constant pool entry fail with the same error (JVMS 5.4.3).
a61af66fc99e Initial load duke parents: diff changeset	245 if (HAS_PENDING_EXCEPTION) {
a61af66fc99e Initial load duke parents: diff changeset	246 ResourceMark rm;
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	247 Symbol* error = PENDING_EXCEPTION->klass()->name();
0 a61af66fc99e Initial load duke parents: diff changeset	248
a61af66fc99e Initial load duke parents: diff changeset	249 bool throw_orig_error = false;
a61af66fc99e Initial load duke parents: diff changeset	250 {
12946 b8860472c377 8014910: deadlock between JVM/TI ClassPrepare event handler and CompilerThread iklam parents: 12850 diff changeset	251 MonitorLockerEx ml(this_oop->lock());
0 a61af66fc99e Initial load duke parents: diff changeset	252
a61af66fc99e Initial load duke parents: diff changeset	253 // some other thread has beaten us and has resolved the class.
a61af66fc99e Initial load duke parents: diff changeset	254 if (this_oop->tag_at(which).is_klass()) {
a61af66fc99e Initial load duke parents: diff changeset	255 CLEAR_PENDING_EXCEPTION;
a61af66fc99e Initial load duke parents: diff changeset	256 entry = this_oop->resolved_klass_at(which);
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	257 return entry.get_klass();
0 a61af66fc99e Initial load duke parents: diff changeset	258 }
a61af66fc99e Initial load duke parents: diff changeset	259
a61af66fc99e Initial load duke parents: diff changeset	260 if (!PENDING_EXCEPTION->
1142 4ce7240d622c 6914300: ciEnv should export all well known classes never parents: 1059 diff changeset	261 is_a(SystemDictionary::LinkageError_klass())) {
0 a61af66fc99e Initial load duke parents: diff changeset	262 // Just throw the exception and don't prevent these classes from
a61af66fc99e Initial load duke parents: diff changeset	263 // being loaded due to virtual machine errors like StackOverflow
a61af66fc99e Initial load duke parents: diff changeset	264 // and OutOfMemoryError, etc, or if the thread was hit by stop()
a61af66fc99e Initial load duke parents: diff changeset	265 // Needs clarification to section 5.4.3 of the VM spec (see 6308271)
a61af66fc99e Initial load duke parents: diff changeset	266 }
a61af66fc99e Initial load duke parents: diff changeset	267 else if (!this_oop->tag_at(which).is_unresolved_klass_in_error()) {
a61af66fc99e Initial load duke parents: diff changeset	268 SystemDictionary::add_resolution_error(this_oop, which, error);
a61af66fc99e Initial load duke parents: diff changeset	269 this_oop->tag_at_put(which, JVM_CONSTANT_UnresolvedClassInError);
a61af66fc99e Initial load duke parents: diff changeset	270 } else {
a61af66fc99e Initial load duke parents: diff changeset	271 // some other thread has put the class in error state.
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	272 error = SystemDictionary::find_resolution_error(this_oop, which);
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	273 assert(error != NULL, "checking");
0 a61af66fc99e Initial load duke parents: diff changeset	274 throw_orig_error = true;
a61af66fc99e Initial load duke parents: diff changeset	275 }
a61af66fc99e Initial load duke parents: diff changeset	276 } // unlocked
a61af66fc99e Initial load duke parents: diff changeset	277
a61af66fc99e Initial load duke parents: diff changeset	278 if (throw_orig_error) {
a61af66fc99e Initial load duke parents: diff changeset	279 CLEAR_PENDING_EXCEPTION;
a61af66fc99e Initial load duke parents: diff changeset	280 ResourceMark rm;
a61af66fc99e Initial load duke parents: diff changeset	281 const char* className = this_oop->unresolved_klass_at(which)->as_C_string();
a61af66fc99e Initial load duke parents: diff changeset	282 THROW_MSG_0(error, className);
a61af66fc99e Initial load duke parents: diff changeset	283 }
a61af66fc99e Initial load duke parents: diff changeset	284
a61af66fc99e Initial load duke parents: diff changeset	285 return 0;
a61af66fc99e Initial load duke parents: diff changeset	286 }
a61af66fc99e Initial load duke parents: diff changeset	287
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	288 if (TraceClassResolution && !k()->oop_is_array()) {
0 a61af66fc99e Initial load duke parents: diff changeset	289 // skip resolving the constant pool so that this code get's
a61af66fc99e Initial load duke parents: diff changeset	290 // called the next time some bytecodes refer to this class.
a61af66fc99e Initial load duke parents: diff changeset	291 ResourceMark rm;
a61af66fc99e Initial load duke parents: diff changeset	292 int line_number = -1;
a61af66fc99e Initial load duke parents: diff changeset	293 const char * source_file = NULL;
a61af66fc99e Initial load duke parents: diff changeset	294 if (JavaThread::current()->has_last_Java_frame()) {
a61af66fc99e Initial load duke parents: diff changeset	295 // try to identify the method which called this function.
a61af66fc99e Initial load duke parents: diff changeset	296 vframeStream vfst(JavaThread::current());
a61af66fc99e Initial load duke parents: diff changeset	297 if (!vfst.at_end()) {
a61af66fc99e Initial load duke parents: diff changeset	298 line_number = vfst.method()->line_number_from_bci(vfst.bci());
6940 18fb7da42534 8000725: NPG: method_holder() and pool_holder() and pool_holder field should be InstanceKlass coleenp parents: 6934 diff changeset	299 Symbol* s = vfst.method()->method_holder()->source_file_name();
0 a61af66fc99e Initial load duke parents: diff changeset	300 if (s != NULL) {
a61af66fc99e Initial load duke parents: diff changeset	301 source_file = s->as_C_string();
a61af66fc99e Initial load duke parents: diff changeset	302 }
a61af66fc99e Initial load duke parents: diff changeset	303 }
a61af66fc99e Initial load duke parents: diff changeset	304 }
a61af66fc99e Initial load duke parents: diff changeset	305 if (k() != this_oop->pool_holder()) {
a61af66fc99e Initial load duke parents: diff changeset	306 // only print something if the classes are different
a61af66fc99e Initial load duke parents: diff changeset	307 if (source_file != NULL) {
a61af66fc99e Initial load duke parents: diff changeset	308 tty->print("RESOLVE %s %s %s:%d\n",
6940 18fb7da42534 8000725: NPG: method_holder() and pool_holder() and pool_holder field should be InstanceKlass coleenp parents: 6934 diff changeset	309 this_oop->pool_holder()->external_name(),
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	310 InstanceKlass::cast(k())->external_name(), source_file, line_number);
0 a61af66fc99e Initial load duke parents: diff changeset	311 } else {
a61af66fc99e Initial load duke parents: diff changeset	312 tty->print("RESOLVE %s %s\n",
6940 18fb7da42534 8000725: NPG: method_holder() and pool_holder() and pool_holder field should be InstanceKlass coleenp parents: 6934 diff changeset	313 this_oop->pool_holder()->external_name(),
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	314 InstanceKlass::cast(k())->external_name());
0 a61af66fc99e Initial load duke parents: diff changeset	315 }
a61af66fc99e Initial load duke parents: diff changeset	316 }
a61af66fc99e Initial load duke parents: diff changeset	317 return k();
a61af66fc99e Initial load duke parents: diff changeset	318 } else {
12946 b8860472c377 8014910: deadlock between JVM/TI ClassPrepare event handler and CompilerThread iklam parents: 12850 diff changeset	319 MonitorLockerEx ml(this_oop->lock());
0 a61af66fc99e Initial load duke parents: diff changeset	320 // Only updated constant pool - if it is resolved.
a61af66fc99e Initial load duke parents: diff changeset	321 do_resolve = this_oop->tag_at(which).is_unresolved_klass();
a61af66fc99e Initial load duke parents: diff changeset	322 if (do_resolve) {
6940 18fb7da42534 8000725: NPG: method_holder() and pool_holder() and pool_holder field should be InstanceKlass coleenp parents: 6934 diff changeset	323 ClassLoaderData* this_key = this_oop->pool_holder()->class_loader_data();
7185 90273fc0a981 8000662: NPG: nashorn ant clean test262 out-of-memory with Java heap coleenp parents: 6940 diff changeset	324 this_key->record_dependency(k(), CHECK_NULL); // Can throw OOM
0 a61af66fc99e Initial load duke parents: diff changeset	325 this_oop->klass_at_put(which, k());
a61af66fc99e Initial load duke parents: diff changeset	326 }
a61af66fc99e Initial load duke parents: diff changeset	327 }
a61af66fc99e Initial load duke parents: diff changeset	328 }
a61af66fc99e Initial load duke parents: diff changeset	329
a61af66fc99e Initial load duke parents: diff changeset	330 entry = this_oop->resolved_klass_at(which);
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	331 assert(entry.is_resolved() && entry.get_klass()->is_klass(), "must be resolved at this point");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	332 return entry.get_klass();
0 a61af66fc99e Initial load duke parents: diff changeset	333 }
a61af66fc99e Initial load duke parents: diff changeset	334
a61af66fc99e Initial load duke parents: diff changeset	335
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	336 // Does not update ConstantPool* - to avoid any exception throwing. Used
0 a61af66fc99e Initial load duke parents: diff changeset	337 // by compiler and exception handling. Also used to avoid classloads for
a61af66fc99e Initial load duke parents: diff changeset	338 // instanceof operations. Returns NULL if the class has not been loaded or
a61af66fc99e Initial load duke parents: diff changeset	339 // if the verification of constant pool failed
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	340 Klass* ConstantPool::klass_at_if_loaded(constantPoolHandle this_oop, int which) {
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	341 CPSlot entry = this_oop->slot_at(which);
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	342 if (entry.is_resolved()) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	343 assert(entry.get_klass()->is_klass(), "must be");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	344 return entry.get_klass();
0 a61af66fc99e Initial load duke parents: diff changeset	345 } else {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	346 assert(entry.is_unresolved(), "must be either symbol or klass");
0 a61af66fc99e Initial load duke parents: diff changeset	347 Thread *thread = Thread::current();
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	348 Symbol* name = entry.get_symbol();
6940 18fb7da42534 8000725: NPG: method_holder() and pool_holder() and pool_holder field should be InstanceKlass coleenp parents: 6934 diff changeset	349 oop loader = this_oop->pool_holder()->class_loader();
18fb7da42534 8000725: NPG: method_holder() and pool_holder() and pool_holder field should be InstanceKlass coleenp parents: 6934 diff changeset	350 oop protection_domain = this_oop->pool_holder()->protection_domain();
0 a61af66fc99e Initial load duke parents: diff changeset	351 Handle h_prot (thread, protection_domain);
a61af66fc99e Initial load duke parents: diff changeset	352 Handle h_loader (thread, loader);
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	353 Klass* k = SystemDictionary::find(name, h_loader, h_prot, thread);
0 a61af66fc99e Initial load duke parents: diff changeset	354
a61af66fc99e Initial load duke parents: diff changeset	355 if (k != NULL) {
a61af66fc99e Initial load duke parents: diff changeset	356 // Make sure that resolving is legal
a61af66fc99e Initial load duke parents: diff changeset	357 EXCEPTION_MARK;
a61af66fc99e Initial load duke parents: diff changeset	358 KlassHandle klass(THREAD, k);
a61af66fc99e Initial load duke parents: diff changeset	359 // return NULL if verification fails
a61af66fc99e Initial load duke parents: diff changeset	360 verify_constant_pool_resolve(this_oop, klass, THREAD);
a61af66fc99e Initial load duke parents: diff changeset	361 if (HAS_PENDING_EXCEPTION) {
a61af66fc99e Initial load duke parents: diff changeset	362 CLEAR_PENDING_EXCEPTION;
a61af66fc99e Initial load duke parents: diff changeset	363 return NULL;
a61af66fc99e Initial load duke parents: diff changeset	364 }
a61af66fc99e Initial load duke parents: diff changeset	365 return klass();
a61af66fc99e Initial load duke parents: diff changeset	366 } else {
a61af66fc99e Initial load duke parents: diff changeset	367 return k;
a61af66fc99e Initial load duke parents: diff changeset	368 }
a61af66fc99e Initial load duke parents: diff changeset	369 }
a61af66fc99e Initial load duke parents: diff changeset	370 }
a61af66fc99e Initial load duke parents: diff changeset	371
a61af66fc99e Initial load duke parents: diff changeset	372
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	373 Klass* ConstantPool::klass_ref_at_if_loaded(constantPoolHandle this_oop, int which) {
0 a61af66fc99e Initial load duke parents: diff changeset	374 return klass_at_if_loaded(this_oop, this_oop->klass_ref_index_at(which));
a61af66fc99e Initial load duke parents: diff changeset	375 }
a61af66fc99e Initial load duke parents: diff changeset	376
a61af66fc99e Initial load duke parents: diff changeset	377
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	378 Method* ConstantPool::method_at_if_loaded(constantPoolHandle cpool,
6266 1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 4862 diff changeset	379 int which) {
4862 f457154eee8b 7140882: Don't return booleans from methods returning pointers brutisso parents: 3960 diff changeset	380 if (cpool->cache() == NULL) return NULL; // nothing to load yet
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	381 int cache_index = decode_cpcache_index(which, true);
3461 81d815b05abb 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 2460 diff changeset	382 if (!(cache_index >= 0 && cache_index < cpool->cache()->length())) {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	383 // FIXME: should be an assert
3461 81d815b05abb 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 2460 diff changeset	384 if (PrintMiscellaneous && (Verbose\|\|WizardMode)) {
6266 1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 4862 diff changeset	385 tty->print_cr("bad operand %d in:", which); cpool->print();
3461 81d815b05abb 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 2460 diff changeset	386 }
81d815b05abb 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 2460 diff changeset	387 return NULL;
81d815b05abb 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 2460 diff changeset	388 }
81d815b05abb 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 2460 diff changeset	389 ConstantPoolCacheEntry* e = cpool->cache()->entry_at(cache_index);
6266 1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 4862 diff changeset	390 return e->method_if_resolved(cpool);
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 4862 diff changeset	391 }
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 4862 diff changeset	392
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 4862 diff changeset	393
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	394 bool ConstantPool::has_appendix_at_if_loaded(constantPoolHandle cpool, int which) {
6266 1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 4862 diff changeset	395 if (cpool->cache() == NULL) return false; // nothing to load yet
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	396 int cache_index = decode_cpcache_index(which, true);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	397 ConstantPoolCacheEntry* e = cpool->cache()->entry_at(cache_index);
6266 1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 4862 diff changeset	398 return e->has_appendix();
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 4862 diff changeset	399 }
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 4862 diff changeset	400
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	401 oop ConstantPool::appendix_at_if_loaded(constantPoolHandle cpool, int which) {
6266 1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 4862 diff changeset	402 if (cpool->cache() == NULL) return NULL; // nothing to load yet
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	403 int cache_index = decode_cpcache_index(which, true);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	404 ConstantPoolCacheEntry* e = cpool->cache()->entry_at(cache_index);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	405 return e->appendix_if_resolved(cpool);
3461 81d815b05abb 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 2460 diff changeset	406 }
81d815b05abb 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 2460 diff changeset	407
81d815b05abb 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 2460 diff changeset	408
6822 f6b0eb4e44cf 7200949: JSR 292: rubybench/bench/time/bench_base64.rb fails with jruby.jar not on boot class path twisti parents: 6733 diff changeset	409 bool ConstantPool::has_method_type_at_if_loaded(constantPoolHandle cpool, int which) {
f6b0eb4e44cf 7200949: JSR 292: rubybench/bench/time/bench_base64.rb fails with jruby.jar not on boot class path twisti parents: 6733 diff changeset	410 if (cpool->cache() == NULL) return false; // nothing to load yet
f6b0eb4e44cf 7200949: JSR 292: rubybench/bench/time/bench_base64.rb fails with jruby.jar not on boot class path twisti parents: 6733 diff changeset	411 int cache_index = decode_cpcache_index(which, true);
f6b0eb4e44cf 7200949: JSR 292: rubybench/bench/time/bench_base64.rb fails with jruby.jar not on boot class path twisti parents: 6733 diff changeset	412 ConstantPoolCacheEntry* e = cpool->cache()->entry_at(cache_index);
f6b0eb4e44cf 7200949: JSR 292: rubybench/bench/time/bench_base64.rb fails with jruby.jar not on boot class path twisti parents: 6733 diff changeset	413 return e->has_method_type();
f6b0eb4e44cf 7200949: JSR 292: rubybench/bench/time/bench_base64.rb fails with jruby.jar not on boot class path twisti parents: 6733 diff changeset	414 }
f6b0eb4e44cf 7200949: JSR 292: rubybench/bench/time/bench_base64.rb fails with jruby.jar not on boot class path twisti parents: 6733 diff changeset	415
f6b0eb4e44cf 7200949: JSR 292: rubybench/bench/time/bench_base64.rb fails with jruby.jar not on boot class path twisti parents: 6733 diff changeset	416 oop ConstantPool::method_type_at_if_loaded(constantPoolHandle cpool, int which) {
f6b0eb4e44cf 7200949: JSR 292: rubybench/bench/time/bench_base64.rb fails with jruby.jar not on boot class path twisti parents: 6733 diff changeset	417 if (cpool->cache() == NULL) return NULL; // nothing to load yet
f6b0eb4e44cf 7200949: JSR 292: rubybench/bench/time/bench_base64.rb fails with jruby.jar not on boot class path twisti parents: 6733 diff changeset	418 int cache_index = decode_cpcache_index(which, true);
f6b0eb4e44cf 7200949: JSR 292: rubybench/bench/time/bench_base64.rb fails with jruby.jar not on boot class path twisti parents: 6733 diff changeset	419 ConstantPoolCacheEntry* e = cpool->cache()->entry_at(cache_index);
f6b0eb4e44cf 7200949: JSR 292: rubybench/bench/time/bench_base64.rb fails with jruby.jar not on boot class path twisti parents: 6733 diff changeset	420 return e->method_type_if_resolved(cpool);
f6b0eb4e44cf 7200949: JSR 292: rubybench/bench/time/bench_base64.rb fails with jruby.jar not on boot class path twisti parents: 6733 diff changeset	421 }
f6b0eb4e44cf 7200949: JSR 292: rubybench/bench/time/bench_base64.rb fails with jruby.jar not on boot class path twisti parents: 6733 diff changeset	422
f6b0eb4e44cf 7200949: JSR 292: rubybench/bench/time/bench_base64.rb fails with jruby.jar not on boot class path twisti parents: 6733 diff changeset	423
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	424 Symbol* ConstantPool::impl_name_ref_at(int which, bool uncached) {
726 be93aad57795 6655646: dynamic languages need dynamically linked call sites jrose parents: 579 diff changeset	425 int name_index = name_ref_index_at(impl_name_and_type_ref_index_at(which, uncached));
0 a61af66fc99e Initial load duke parents: diff changeset	426 return symbol_at(name_index);
a61af66fc99e Initial load duke parents: diff changeset	427 }
a61af66fc99e Initial load duke parents: diff changeset	428
a61af66fc99e Initial load duke parents: diff changeset	429
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	430 Symbol* ConstantPool::impl_signature_ref_at(int which, bool uncached) {
726 be93aad57795 6655646: dynamic languages need dynamically linked call sites jrose parents: 579 diff changeset	431 int signature_index = signature_ref_index_at(impl_name_and_type_ref_index_at(which, uncached));
0 a61af66fc99e Initial load duke parents: diff changeset	432 return symbol_at(signature_index);
a61af66fc99e Initial load duke parents: diff changeset	433 }
a61af66fc99e Initial load duke parents: diff changeset	434
a61af66fc99e Initial load duke parents: diff changeset	435
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	436 int ConstantPool::impl_name_and_type_ref_index_at(int which, bool uncached) {
1059 389049f3f393 6858164: invokedynamic code needs some cleanup (post-6655638) jrose parents: 773 diff changeset	437 int i = which;
389049f3f393 6858164: invokedynamic code needs some cleanup (post-6655638) jrose parents: 773 diff changeset	438 if (!uncached && cache() != NULL) {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	439 if (ConstantPool::is_invokedynamic_index(which)) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	440 // Invokedynamic index is index into resolved_references
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	441 int pool_index = invokedynamic_cp_cache_entry_at(which)->constant_pool_index();
2460 ed69575596ac 6981791: remove experimental code for JSR 292 jrose parents: 2376 diff changeset	442 pool_index = invoke_dynamic_name_and_type_ref_index_at(pool_index);
1660 083fde3b838e 6964498: JSR 292 invokedynamic sites need local bootstrap methods jrose parents: 1602 diff changeset	443 assert(tag_at(pool_index).is_name_and_type(), "");
083fde3b838e 6964498: JSR 292 invokedynamic sites need local bootstrap methods jrose parents: 1602 diff changeset	444 return pool_index;
083fde3b838e 6964498: JSR 292 invokedynamic sites need local bootstrap methods jrose parents: 1602 diff changeset	445 }
1059 389049f3f393 6858164: invokedynamic code needs some cleanup (post-6655638) jrose parents: 773 diff changeset	446 // change byte-ordering and go via cache
389049f3f393 6858164: invokedynamic code needs some cleanup (post-6655638) jrose parents: 773 diff changeset	447 i = remap_instruction_operand_from_cache(which);
389049f3f393 6858164: invokedynamic code needs some cleanup (post-6655638) jrose parents: 773 diff changeset	448 } else {
1913 3b2dea75431e 6984311: JSR 292 needs optional bootstrap method parameters jrose parents: 1910 diff changeset	449 if (tag_at(which).is_invoke_dynamic()) {
3b2dea75431e 6984311: JSR 292 needs optional bootstrap method parameters jrose parents: 1910 diff changeset	450 int pool_index = invoke_dynamic_name_and_type_ref_index_at(which);
3b2dea75431e 6984311: JSR 292 needs optional bootstrap method parameters jrose parents: 1910 diff changeset	451 assert(tag_at(pool_index).is_name_and_type(), "");
3b2dea75431e 6984311: JSR 292 needs optional bootstrap method parameters jrose parents: 1910 diff changeset	452 return pool_index;
3b2dea75431e 6984311: JSR 292 needs optional bootstrap method parameters jrose parents: 1910 diff changeset	453 }
1059 389049f3f393 6858164: invokedynamic code needs some cleanup (post-6655638) jrose parents: 773 diff changeset	454 }
389049f3f393 6858164: invokedynamic code needs some cleanup (post-6655638) jrose parents: 773 diff changeset	455 assert(tag_at(i).is_field_or_method(), "Corrupted constant pool");
1913 3b2dea75431e 6984311: JSR 292 needs optional bootstrap method parameters jrose parents: 1910 diff changeset	456 assert(!tag_at(i).is_invoke_dynamic(), "Must be handled above");
1059 389049f3f393 6858164: invokedynamic code needs some cleanup (post-6655638) jrose parents: 773 diff changeset	457 jint ref_index = *int_at_addr(i);
0 a61af66fc99e Initial load duke parents: diff changeset	458 return extract_high_short_from_int(ref_index);
a61af66fc99e Initial load duke parents: diff changeset	459 }
a61af66fc99e Initial load duke parents: diff changeset	460
a61af66fc99e Initial load duke parents: diff changeset	461
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	462 int ConstantPool::impl_klass_ref_index_at(int which, bool uncached) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	463 guarantee(!ConstantPool::is_invokedynamic_index(which),
1059 389049f3f393 6858164: invokedynamic code needs some cleanup (post-6655638) jrose parents: 773 diff changeset	464 "an invokedynamic instruction does not have a klass");
389049f3f393 6858164: invokedynamic code needs some cleanup (post-6655638) jrose parents: 773 diff changeset	465 int i = which;
389049f3f393 6858164: invokedynamic code needs some cleanup (post-6655638) jrose parents: 773 diff changeset	466 if (!uncached && cache() != NULL) {
389049f3f393 6858164: invokedynamic code needs some cleanup (post-6655638) jrose parents: 773 diff changeset	467 // change byte-ordering and go via cache
389049f3f393 6858164: invokedynamic code needs some cleanup (post-6655638) jrose parents: 773 diff changeset	468 i = remap_instruction_operand_from_cache(which);
389049f3f393 6858164: invokedynamic code needs some cleanup (post-6655638) jrose parents: 773 diff changeset	469 }
389049f3f393 6858164: invokedynamic code needs some cleanup (post-6655638) jrose parents: 773 diff changeset	470 assert(tag_at(i).is_field_or_method(), "Corrupted constant pool");
389049f3f393 6858164: invokedynamic code needs some cleanup (post-6655638) jrose parents: 773 diff changeset	471 jint ref_index = *int_at_addr(i);
0 a61af66fc99e Initial load duke parents: diff changeset	472 return extract_low_short_from_int(ref_index);
a61af66fc99e Initial load duke parents: diff changeset	473 }
a61af66fc99e Initial load duke parents: diff changeset	474
a61af66fc99e Initial load duke parents: diff changeset	475
726 be93aad57795 6655646: dynamic languages need dynamically linked call sites jrose parents: 579 diff changeset	476
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	477 int ConstantPool::remap_instruction_operand_from_cache(int operand) {
1565 ab102d5d923e 6939207: refactor constant pool index processing jrose parents: 1142 diff changeset	478 int cpc_index = operand;
ab102d5d923e 6939207: refactor constant pool index processing jrose parents: 1142 diff changeset	479 DEBUG_ONLY(cpc_index -= CPCACHE_INDEX_TAG);
ab102d5d923e 6939207: refactor constant pool index processing jrose parents: 1142 diff changeset	480 assert((int)(u2)cpc_index == cpc_index, "clean u2");
1059 389049f3f393 6858164: invokedynamic code needs some cleanup (post-6655638) jrose parents: 773 diff changeset	481 int member_index = cache()->entry_at(cpc_index)->constant_pool_index();
389049f3f393 6858164: invokedynamic code needs some cleanup (post-6655638) jrose parents: 773 diff changeset	482 return member_index;
726 be93aad57795 6655646: dynamic languages need dynamically linked call sites jrose parents: 579 diff changeset	483 }
be93aad57795 6655646: dynamic languages need dynamically linked call sites jrose parents: 579 diff changeset	484
be93aad57795 6655646: dynamic languages need dynamically linked call sites jrose parents: 579 diff changeset	485
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	486 void ConstantPool::verify_constant_pool_resolve(constantPoolHandle this_oop, KlassHandle k, TRAPS) {
0 a61af66fc99e Initial load duke parents: diff changeset	487 if (k->oop_is_instance() \|\| k->oop_is_objArray()) {
a61af66fc99e Initial load duke parents: diff changeset	488 instanceKlassHandle holder (THREAD, this_oop->pool_holder());
6831 d8ce2825b193 8000213: NPG: Should have renamed arrayKlass and typeArrayKlass coleenp parents: 6733 diff changeset	489 Klass* elem_oop = k->oop_is_instance() ? k() : ObjArrayKlass::cast(k())->bottom_klass();
0 a61af66fc99e Initial load duke parents: diff changeset	490 KlassHandle element (THREAD, elem_oop);
a61af66fc99e Initial load duke parents: diff changeset	491
a61af66fc99e Initial load duke parents: diff changeset	492 // The element type could be a typeArray - we only need the access check if it is
a61af66fc99e Initial load duke parents: diff changeset	493 // an reference to another class
a61af66fc99e Initial load duke parents: diff changeset	494 if (element->oop_is_instance()) {
a61af66fc99e Initial load duke parents: diff changeset	495 LinkResolver::check_klass_accessability(holder, element, CHECK);
a61af66fc99e Initial load duke parents: diff changeset	496 }
a61af66fc99e Initial load duke parents: diff changeset	497 }
a61af66fc99e Initial load duke parents: diff changeset	498 }
a61af66fc99e Initial load duke parents: diff changeset	499
a61af66fc99e Initial load duke parents: diff changeset	500
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	501 int ConstantPool::name_ref_index_at(int which_nt) {
726 be93aad57795 6655646: dynamic languages need dynamically linked call sites jrose parents: 579 diff changeset	502 jint ref_index = name_and_type_at(which_nt);
0 a61af66fc99e Initial load duke parents: diff changeset	503 return extract_low_short_from_int(ref_index);
a61af66fc99e Initial load duke parents: diff changeset	504 }
a61af66fc99e Initial load duke parents: diff changeset	505
a61af66fc99e Initial load duke parents: diff changeset	506
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	507 int ConstantPool::signature_ref_index_at(int which_nt) {
726 be93aad57795 6655646: dynamic languages need dynamically linked call sites jrose parents: 579 diff changeset	508 jint ref_index = name_and_type_at(which_nt);
0 a61af66fc99e Initial load duke parents: diff changeset	509 return extract_high_short_from_int(ref_index);
a61af66fc99e Initial load duke parents: diff changeset	510 }
a61af66fc99e Initial load duke parents: diff changeset	511
a61af66fc99e Initial load duke parents: diff changeset	512
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	513 Klass* ConstantPool::klass_ref_at(int which, TRAPS) {
0 a61af66fc99e Initial load duke parents: diff changeset	514 return klass_at(klass_ref_index_at(which), CHECK_NULL);
a61af66fc99e Initial load duke parents: diff changeset	515 }
a61af66fc99e Initial load duke parents: diff changeset	516
a61af66fc99e Initial load duke parents: diff changeset	517
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	518 Symbol* ConstantPool::klass_name_at(int which) {
0 a61af66fc99e Initial load duke parents: diff changeset	519 assert(tag_at(which).is_unresolved_klass() \|\| tag_at(which).is_klass(),
a61af66fc99e Initial load duke parents: diff changeset	520 "Corrupted constant pool");
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	521 // A resolved constantPool entry will contain a Klass, otherwise a Symbol.
0 a61af66fc99e Initial load duke parents: diff changeset	522 // It is not safe to rely on the tag bit's here, since we don't have a lock, and the entry and
a61af66fc99e Initial load duke parents: diff changeset	523 // tag is not updated atomicly.
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	524 CPSlot entry = slot_at(which);
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	525 if (entry.is_resolved()) {
0 a61af66fc99e Initial load duke parents: diff changeset	526 // Already resolved - return entry's name.
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	527 assert(entry.get_klass()->is_klass(), "must be");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	528 return entry.get_klass()->name();
0 a61af66fc99e Initial load duke parents: diff changeset	529 } else {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	530 assert(entry.is_unresolved(), "must be either symbol or klass");
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	531 return entry.get_symbol();
0 a61af66fc99e Initial load duke parents: diff changeset	532 }
a61af66fc99e Initial load duke parents: diff changeset	533 }
a61af66fc99e Initial load duke parents: diff changeset	534
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	535 Symbol* ConstantPool::klass_ref_at_noresolve(int which) {
0 a61af66fc99e Initial load duke parents: diff changeset	536 jint ref_index = klass_ref_index_at(which);
a61af66fc99e Initial load duke parents: diff changeset	537 return klass_at_noresolve(ref_index);
a61af66fc99e Initial load duke parents: diff changeset	538 }
a61af66fc99e Initial load duke parents: diff changeset	539
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	540 Symbol* ConstantPool::uncached_klass_ref_at_noresolve(int which) {
1602 136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	541 jint ref_index = uncached_klass_ref_index_at(which);
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	542 return klass_at_noresolve(ref_index);
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	543 }
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	544
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	545 char* ConstantPool::string_at_noresolve(int which) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	546 Symbol* s = unresolved_string_at(which);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	547 if (s == NULL) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	548 return (char*)"<pseudo-string>";
0 a61af66fc99e Initial load duke parents: diff changeset	549 } else {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	550 return unresolved_string_at(which)->as_C_string();
0 a61af66fc99e Initial load duke parents: diff changeset	551 }
a61af66fc99e Initial load duke parents: diff changeset	552 }
a61af66fc99e Initial load duke parents: diff changeset	553
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	554 BasicType ConstantPool::basic_type_for_signature_at(int which) {
0 a61af66fc99e Initial load duke parents: diff changeset	555 return FieldType::basic_type(symbol_at(which));
a61af66fc99e Initial load duke parents: diff changeset	556 }
a61af66fc99e Initial load duke parents: diff changeset	557
a61af66fc99e Initial load duke parents: diff changeset	558
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	559 void ConstantPool::resolve_string_constants_impl(constantPoolHandle this_oop, TRAPS) {
0 a61af66fc99e Initial load duke parents: diff changeset	560 for (int index = 1; index < this_oop->length(); index++) { // Index 0 is unused
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	561 if (this_oop->tag_at(index).is_string()) {
0 a61af66fc99e Initial load duke parents: diff changeset	562 this_oop->string_at(index, CHECK);
a61af66fc99e Initial load duke parents: diff changeset	563 }
a61af66fc99e Initial load duke parents: diff changeset	564 }
a61af66fc99e Initial load duke parents: diff changeset	565 }
a61af66fc99e Initial load duke parents: diff changeset	566
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	567 // Resolve all the classes in the constant pool. If they are all resolved,
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	568 // the constant pool is read-only. Enhancement: allocate cp entries to
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	569 // another metaspace, and copy to read-only or read-write space if this
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	570 // bit is set.
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	571 bool ConstantPool::resolve_class_constants(TRAPS) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	572 constantPoolHandle cp(THREAD, this);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	573 for (int index = 1; index < length(); index++) { // Index 0 is unused
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	574 if (tag_at(index).is_unresolved_klass() &&
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	575 klass_at_if_loaded(cp, index) == NULL) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	576 return false;
1913 3b2dea75431e 6984311: JSR 292 needs optional bootstrap method parameters jrose parents: 1910 diff changeset	577 }
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	578 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	579 // set_preresolution(); or some bit for future use
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	580 return true;
1913 3b2dea75431e 6984311: JSR 292 needs optional bootstrap method parameters jrose parents: 1910 diff changeset	581 }
3b2dea75431e 6984311: JSR 292 needs optional bootstrap method parameters jrose parents: 1910 diff changeset	582
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	583 // If resolution for MethodHandle or MethodType fails, save the exception
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	584 // in the resolution error table, so that the same exception is thrown again.
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	585 void ConstantPool::save_and_throw_exception(constantPoolHandle this_oop, int which,
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	586 int tag, TRAPS) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	587 ResourceMark rm;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	588 Symbol* error = PENDING_EXCEPTION->klass()->name();
12946 b8860472c377 8014910: deadlock between JVM/TI ClassPrepare event handler and CompilerThread iklam parents: 12850 diff changeset	589 MonitorLockerEx ml(this_oop->lock()); // lock cpool to change tag.
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	590
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	591 int error_tag = (tag == JVM_CONSTANT_MethodHandle) ?
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	592 JVM_CONSTANT_MethodHandleInError : JVM_CONSTANT_MethodTypeInError;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	593
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	594 if (!PENDING_EXCEPTION->
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	595 is_a(SystemDictionary::LinkageError_klass())) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	596 // Just throw the exception and don't prevent these classes from
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	597 // being loaded due to virtual machine errors like StackOverflow
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	598 // and OutOfMemoryError, etc, or if the thread was hit by stop()
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	599 // Needs clarification to section 5.4.3 of the VM spec (see 6308271)
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	600
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	601 } else if (this_oop->tag_at(which).value() != error_tag) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	602 SystemDictionary::add_resolution_error(this_oop, which, error);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	603 this_oop->tag_at_put(which, error_tag);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	604 } else {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	605 // some other thread has put the class in error state.
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	606 error = SystemDictionary::find_resolution_error(this_oop, which);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	607 assert(error != NULL, "checking");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	608 CLEAR_PENDING_EXCEPTION;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	609 THROW_MSG(error, "");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	610 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	611 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	612
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	613
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	614 // Called to resolve constants in the constant pool and return an oop.
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	615 // Some constant pool entries cache their resolved oop. This is also
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	616 // called to create oops from constants to use in arguments for invokedynamic
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	617 oop ConstantPool::resolve_constant_at_impl(constantPoolHandle this_oop, int index, int cache_index, TRAPS) {
1602 136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	618 oop result_oop = NULL;
1913 3b2dea75431e 6984311: JSR 292 needs optional bootstrap method parameters jrose parents: 1910 diff changeset	619 Handle throw_exception;
3b2dea75431e 6984311: JSR 292 needs optional bootstrap method parameters jrose parents: 1910 diff changeset	620
3b2dea75431e 6984311: JSR 292 needs optional bootstrap method parameters jrose parents: 1910 diff changeset	621 if (cache_index == _possible_index_sentinel) {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	622 // It is possible that this constant is one which is cached in the objects.
1913 3b2dea75431e 6984311: JSR 292 needs optional bootstrap method parameters jrose parents: 1910 diff changeset	623 // We'll do a linear search. This should be OK because this usage is rare.
3b2dea75431e 6984311: JSR 292 needs optional bootstrap method parameters jrose parents: 1910 diff changeset	624 assert(index > 0, "valid index");
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	625 cache_index = this_oop->cp_to_object_index(index);
1913 3b2dea75431e 6984311: JSR 292 needs optional bootstrap method parameters jrose parents: 1910 diff changeset	626 }
3b2dea75431e 6984311: JSR 292 needs optional bootstrap method parameters jrose parents: 1910 diff changeset	627 assert(cache_index == _no_index_sentinel \|\| cache_index >= 0, "");
3b2dea75431e 6984311: JSR 292 needs optional bootstrap method parameters jrose parents: 1910 diff changeset	628 assert(index == _no_index_sentinel \|\| index >= 0, "");
3b2dea75431e 6984311: JSR 292 needs optional bootstrap method parameters jrose parents: 1910 diff changeset	629
1602 136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	630 if (cache_index >= 0) {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	631 result_oop = this_oop->resolved_references()->obj_at(cache_index);
1602 136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	632 if (result_oop != NULL) {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	633 return result_oop;
1913 3b2dea75431e 6984311: JSR 292 needs optional bootstrap method parameters jrose parents: 1910 diff changeset	634 // That was easy...
1602 136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	635 }
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	636 index = this_oop->object_to_cp_index(cache_index);
1602 136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	637 }
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	638
1913 3b2dea75431e 6984311: JSR 292 needs optional bootstrap method parameters jrose parents: 1910 diff changeset	639 jvalue prim_value; // temp used only in a few cases below
3b2dea75431e 6984311: JSR 292 needs optional bootstrap method parameters jrose parents: 1910 diff changeset	640
1602 136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	641 int tag_value = this_oop->tag_at(index).value();
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	642
1602 136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	643 switch (tag_value) {
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	644
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	645 case JVM_CONSTANT_UnresolvedClass:
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	646 case JVM_CONSTANT_UnresolvedClassInError:
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	647 case JVM_CONSTANT_Class:
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	648 {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	649 assert(cache_index == _no_index_sentinel, "should not have been set");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	650 Klass* resolved = klass_at_impl(this_oop, index, CHECK_NULL);
1602 136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	651 // ldc wants the java mirror.
2376 c7f3d0b4570f 7017732: move static fields into Class to prepare for perm gen removal never parents: 2332 diff changeset	652 result_oop = resolved->java_mirror();
1602 136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	653 break;
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	654 }
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	655
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	656 case JVM_CONSTANT_String:
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	657 assert(cache_index != _no_index_sentinel, "should have been set");
1602 136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	658 if (this_oop->is_pseudo_string_at(index)) {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	659 result_oop = this_oop->pseudo_string_at(index, cache_index);
1602 136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	660 break;
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	661 }
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	662 result_oop = string_at_impl(this_oop, index, cache_index, CHECK_NULL);
1602 136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	663 break;
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	664
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	665 case JVM_CONSTANT_MethodHandleInError:
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	666 case JVM_CONSTANT_MethodTypeInError:
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	667 {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	668 Symbol* error = SystemDictionary::find_resolution_error(this_oop, index);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	669 guarantee(error != (Symbol*)NULL, "tag mismatch with resolution error table");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	670 ResourceMark rm;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	671 THROW_MSG_0(error, "");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	672 break;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	673 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	674
1602 136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	675 case JVM_CONSTANT_MethodHandle:
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	676 {
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	677 int ref_kind = this_oop->method_handle_ref_kind_at(index);
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	678 int callee_index = this_oop->method_handle_klass_index_at(index);
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	679 Symbol* name = this_oop->method_handle_name_ref_at(index);
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	680 Symbol* signature = this_oop->method_handle_signature_ref_at(index);
1602 136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	681 if (PrintMiscellaneous)
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	682 tty->print_cr("resolve JVM_CONSTANT_MethodHandle:%d [%d/%d/%d] %s.%s",
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	683 ref_kind, index, this_oop->method_handle_index_at(index),
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	684 callee_index, name->as_C_string(), signature->as_C_string());
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	685 KlassHandle callee;
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	686 { Klass* k = klass_at_impl(this_oop, callee_index, CHECK_NULL);
1602 136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	687 callee = KlassHandle(THREAD, k);
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	688 }
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	689 KlassHandle klass(THREAD, this_oop->pool_holder());
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	690 Handle value = SystemDictionary::link_method_handle_constant(klass, ref_kind,
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	691 callee, name, signature,
1913 3b2dea75431e 6984311: JSR 292 needs optional bootstrap method parameters jrose parents: 1910 diff changeset	692 THREAD);
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	693 result_oop = value();
1913 3b2dea75431e 6984311: JSR 292 needs optional bootstrap method parameters jrose parents: 1910 diff changeset	694 if (HAS_PENDING_EXCEPTION) {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	695 save_and_throw_exception(this_oop, index, tag_value, CHECK_NULL);
1913 3b2dea75431e 6984311: JSR 292 needs optional bootstrap method parameters jrose parents: 1910 diff changeset	696 }
1602 136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	697 break;
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	698 }
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	699
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	700 case JVM_CONSTANT_MethodType:
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	701 {
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	702 Symbol* signature = this_oop->method_type_signature_at(index);
1602 136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	703 if (PrintMiscellaneous)
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	704 tty->print_cr("resolve JVM_CONSTANT_MethodType [%d/%d] %s",
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	705 index, this_oop->method_type_index_at(index),
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	706 signature->as_C_string());
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	707 KlassHandle klass(THREAD, this_oop->pool_holder());
6266 1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 4862 diff changeset	708 Handle value = SystemDictionary::find_method_handle_type(signature, klass, THREAD);
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	709 result_oop = value();
1913 3b2dea75431e 6984311: JSR 292 needs optional bootstrap method parameters jrose parents: 1910 diff changeset	710 if (HAS_PENDING_EXCEPTION) {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	711 save_and_throw_exception(this_oop, index, tag_value, CHECK_NULL);
1913 3b2dea75431e 6984311: JSR 292 needs optional bootstrap method parameters jrose parents: 1910 diff changeset	712 }
1602 136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	713 break;
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	714 }
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	715
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	716 case JVM_CONSTANT_Integer:
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	717 assert(cache_index == _no_index_sentinel, "should not have been set");
1913 3b2dea75431e 6984311: JSR 292 needs optional bootstrap method parameters jrose parents: 1910 diff changeset	718 prim_value.i = this_oop->int_at(index);
3b2dea75431e 6984311: JSR 292 needs optional bootstrap method parameters jrose parents: 1910 diff changeset	719 result_oop = java_lang_boxing_object::create(T_INT, &prim_value, CHECK_NULL);
3b2dea75431e 6984311: JSR 292 needs optional bootstrap method parameters jrose parents: 1910 diff changeset	720 break;
3b2dea75431e 6984311: JSR 292 needs optional bootstrap method parameters jrose parents: 1910 diff changeset	721
1602 136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	722 case JVM_CONSTANT_Float:
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	723 assert(cache_index == _no_index_sentinel, "should not have been set");
1913 3b2dea75431e 6984311: JSR 292 needs optional bootstrap method parameters jrose parents: 1910 diff changeset	724 prim_value.f = this_oop->float_at(index);
3b2dea75431e 6984311: JSR 292 needs optional bootstrap method parameters jrose parents: 1910 diff changeset	725 result_oop = java_lang_boxing_object::create(T_FLOAT, &prim_value, CHECK_NULL);
3b2dea75431e 6984311: JSR 292 needs optional bootstrap method parameters jrose parents: 1910 diff changeset	726 break;
3b2dea75431e 6984311: JSR 292 needs optional bootstrap method parameters jrose parents: 1910 diff changeset	727
1602 136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	728 case JVM_CONSTANT_Long:
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	729 assert(cache_index == _no_index_sentinel, "should not have been set");
1913 3b2dea75431e 6984311: JSR 292 needs optional bootstrap method parameters jrose parents: 1910 diff changeset	730 prim_value.j = this_oop->long_at(index);
3b2dea75431e 6984311: JSR 292 needs optional bootstrap method parameters jrose parents: 1910 diff changeset	731 result_oop = java_lang_boxing_object::create(T_LONG, &prim_value, CHECK_NULL);
3b2dea75431e 6984311: JSR 292 needs optional bootstrap method parameters jrose parents: 1910 diff changeset	732 break;
3b2dea75431e 6984311: JSR 292 needs optional bootstrap method parameters jrose parents: 1910 diff changeset	733
1602 136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	734 case JVM_CONSTANT_Double:
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	735 assert(cache_index == _no_index_sentinel, "should not have been set");
1913 3b2dea75431e 6984311: JSR 292 needs optional bootstrap method parameters jrose parents: 1910 diff changeset	736 prim_value.d = this_oop->double_at(index);
3b2dea75431e 6984311: JSR 292 needs optional bootstrap method parameters jrose parents: 1910 diff changeset	737 result_oop = java_lang_boxing_object::create(T_DOUBLE, &prim_value, CHECK_NULL);
1602 136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	738 break;
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	739
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	740 default:
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	741 DEBUG_ONLY( tty->print_cr("*** %p: tag at CP[%d/%d] = %d",
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	742 this_oop(), index, cache_index, tag_value) );
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	743 assert(false, "unexpected constant tag");
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	744 break;
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	745 }
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	746
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	747 if (cache_index >= 0) {
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	748 // Cache the oop here also.
1913 3b2dea75431e 6984311: JSR 292 needs optional bootstrap method parameters jrose parents: 1910 diff changeset	749 Handle result_handle(THREAD, result_oop);
12946 b8860472c377 8014910: deadlock between JVM/TI ClassPrepare event handler and CompilerThread iklam parents: 12850 diff changeset	750 MonitorLockerEx ml(this_oop->lock()); // don't know if we really need this
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	751 oop result = this_oop->resolved_references()->obj_at(cache_index);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	752 // Benign race condition: resolved_references may already be filled in while we were trying to lock.
1913 3b2dea75431e 6984311: JSR 292 needs optional bootstrap method parameters jrose parents: 1910 diff changeset	753 // The important thing here is that all threads pick up the same result.
3b2dea75431e 6984311: JSR 292 needs optional bootstrap method parameters jrose parents: 1910 diff changeset	754 // It doesn't matter which racing thread wins, as long as only one
3b2dea75431e 6984311: JSR 292 needs optional bootstrap method parameters jrose parents: 1910 diff changeset	755 // result is used by all threads, and all future queries.
3b2dea75431e 6984311: JSR 292 needs optional bootstrap method parameters jrose parents: 1910 diff changeset	756 // That result may be either a resolved constant or a failure exception.
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	757 if (result == NULL) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	758 this_oop->resolved_references()->obj_at_put(cache_index, result_handle());
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	759 return result_handle();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	760 } else {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	761 // Return the winning thread's result. This can be different than
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	762 // result_handle() for MethodHandles.
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	763 return result;
1602 136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	764 }
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	765 } else {
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	766 return result_oop;
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	767 }
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	768 }
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	769
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	770 oop ConstantPool::uncached_string_at(int which, TRAPS) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	771 Symbol* sym = unresolved_string_at(which);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	772 oop str = StringTable::intern(sym, CHECK_(NULL));
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	773 assert(java_lang_String::is_instance(str), "must be string");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	774 return str;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	775 }
6266 1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 4862 diff changeset	776
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	777
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	778 oop ConstantPool::resolve_bootstrap_specifier_at_impl(constantPoolHandle this_oop, int index, TRAPS) {
6266 1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 4862 diff changeset	779 assert(this_oop->tag_at(index).is_invoke_dynamic(), "Corrupted constant pool");
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 4862 diff changeset	780
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 4862 diff changeset	781 Handle bsm;
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 4862 diff changeset	782 int argc;
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 4862 diff changeset	783 {
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 4862 diff changeset	784 // JVM_CONSTANT_InvokeDynamic is an ordered pair of [bootm, name&type], plus optional arguments
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 4862 diff changeset	785 // The bootm, being a JVM_CONSTANT_MethodHandle, has its own cache entry.
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 4862 diff changeset	786 // It is accompanied by the optional arguments.
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 4862 diff changeset	787 int bsm_index = this_oop->invoke_dynamic_bootstrap_method_ref_index_at(index);
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 4862 diff changeset	788 oop bsm_oop = this_oop->resolve_possibly_cached_constant_at(bsm_index, CHECK_NULL);
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 4862 diff changeset	789 if (!java_lang_invoke_MethodHandle::is_instance(bsm_oop)) {
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 4862 diff changeset	790 THROW_MSG_NULL(vmSymbols::java_lang_LinkageError(), "BSM not an MethodHandle");
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 4862 diff changeset	791 }
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 4862 diff changeset	792
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 4862 diff changeset	793 // Extract the optional static arguments.
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 4862 diff changeset	794 argc = this_oop->invoke_dynamic_argument_count_at(index);
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 4862 diff changeset	795 if (argc == 0) return bsm_oop;
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 4862 diff changeset	796
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 4862 diff changeset	797 bsm = Handle(THREAD, bsm_oop);
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 4862 diff changeset	798 }
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 4862 diff changeset	799
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 4862 diff changeset	800 objArrayHandle info;
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 4862 diff changeset	801 {
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 4862 diff changeset	802 objArrayOop info_oop = oopFactory::new_objArray(SystemDictionary::Object_klass(), 1+argc, CHECK_NULL);
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 4862 diff changeset	803 info = objArrayHandle(THREAD, info_oop);
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 4862 diff changeset	804 }
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 4862 diff changeset	805
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 4862 diff changeset	806 info->obj_at_put(0, bsm());
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 4862 diff changeset	807 for (int i = 0; i < argc; i++) {
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 4862 diff changeset	808 int arg_index = this_oop->invoke_dynamic_argument_index_at(index, i);
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 4862 diff changeset	809 oop arg_oop = this_oop->resolve_possibly_cached_constant_at(arg_index, CHECK_NULL);
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 4862 diff changeset	810 info->obj_at_put(1+i, arg_oop);
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 4862 diff changeset	811 }
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 4862 diff changeset	812
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 4862 diff changeset	813 return info();
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 4862 diff changeset	814 }
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 4862 diff changeset	815
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	816 oop ConstantPool::string_at_impl(constantPoolHandle this_oop, int which, int obj_index, TRAPS) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	817 // If the string has already been interned, this entry will be non-null
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	818 oop str = this_oop->resolved_references()->obj_at(obj_index);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	819 if (str != NULL) return str;
12285 7c29904fdfa2 8014956: nashorn/api/javaaccess/MethodAccessTest.java test fails on sparc-solaris 64 coleenp parents: 11034 diff changeset	820 Symbol* sym = this_oop->unresolved_string_at(which);
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	821 str = StringTable::intern(sym, CHECK_(NULL));
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	822 this_oop->string_at_put(which, obj_index, str);
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	823 assert(java_lang_String::is_instance(str), "must be string");
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	824 return str;
0 a61af66fc99e Initial load duke parents: diff changeset	825 }
a61af66fc99e Initial load duke parents: diff changeset	826
a61af66fc99e Initial load duke parents: diff changeset	827
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	828 bool ConstantPool::klass_name_at_matches(instanceKlassHandle k,
0 a61af66fc99e Initial load duke parents: diff changeset	829 int which) {
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	830 // Names are interned, so we can compare Symbol*s directly
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	831 Symbol* cp_name = klass_name_at(which);
0 a61af66fc99e Initial load duke parents: diff changeset	832 return (cp_name == k->name());
a61af66fc99e Initial load duke parents: diff changeset	833 }
a61af66fc99e Initial load duke parents: diff changeset	834
a61af66fc99e Initial load duke parents: diff changeset	835
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	836 // Iterate over symbols and decrement ones which are Symbol*s.
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	837 // This is done during GC so do not need to lock constantPool unless we
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	838 // have per-thread safepoints.
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	839 // Only decrement the UTF8 symbols. Unresolved classes and strings point to
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	840 // these symbols but didn't increment the reference count.
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	841 void ConstantPool::unreference_symbols() {
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	842 for (int index = 1; index < length(); index++) { // Index 0 is unused
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	843 constantTag tag = tag_at(index);
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	844 if (tag.is_symbol()) {
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	845 symbol_at(index)->decrement_refcount();
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	846 }
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	847 }
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	848 }
0 a61af66fc99e Initial load duke parents: diff changeset	849
a61af66fc99e Initial load duke parents: diff changeset	850
a61af66fc99e Initial load duke parents: diff changeset	851 // Compare this constant pool's entry at index1 to the constant pool
a61af66fc99e Initial load duke parents: diff changeset	852 // cp2's entry at index2.
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	853 bool ConstantPool::compare_entry_to(int index1, constantPoolHandle cp2,
0 a61af66fc99e Initial load duke parents: diff changeset	854 int index2, TRAPS) {
a61af66fc99e Initial load duke parents: diff changeset	855
12850 28ca974cc21a 8022592: assert at constantTag.cpp:57: ShouldNotReachHere() coleenp parents: 12845 diff changeset	856 // The error tags are equivalent to non-error tags when comparing
28ca974cc21a 8022592: assert at constantTag.cpp:57: ShouldNotReachHere() coleenp parents: 12845 diff changeset	857 jbyte t1 = tag_at(index1).non_error_value();
28ca974cc21a 8022592: assert at constantTag.cpp:57: ShouldNotReachHere() coleenp parents: 12845 diff changeset	858 jbyte t2 = cp2->tag_at(index2).non_error_value();
0 a61af66fc99e Initial load duke parents: diff changeset	859
a61af66fc99e Initial load duke parents: diff changeset	860 if (t1 != t2) {
a61af66fc99e Initial load duke parents: diff changeset	861 // Not the same entry type so there is nothing else to check. Note
a61af66fc99e Initial load duke parents: diff changeset	862 // that this style of checking will consider resolved/unresolved
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	863 // class pairs as different.
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	864 // From the ConstantPool* API point of view, this is correct
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	865 // behavior. See VM_RedefineClasses::merge_constant_pools() to see how this
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	866 // plays out in the context of ConstantPool* merging.
0 a61af66fc99e Initial load duke parents: diff changeset	867 return false;
a61af66fc99e Initial load duke parents: diff changeset	868 }
a61af66fc99e Initial load duke parents: diff changeset	869
a61af66fc99e Initial load duke parents: diff changeset	870 switch (t1) {
a61af66fc99e Initial load duke parents: diff changeset	871 case JVM_CONSTANT_Class:
a61af66fc99e Initial load duke parents: diff changeset	872 {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	873 Klass* k1 = klass_at(index1, CHECK_false);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	874 Klass* k2 = cp2->klass_at(index2, CHECK_false);
0 a61af66fc99e Initial load duke parents: diff changeset	875 if (k1 == k2) {
a61af66fc99e Initial load duke parents: diff changeset	876 return true;
a61af66fc99e Initial load duke parents: diff changeset	877 }
a61af66fc99e Initial load duke parents: diff changeset	878 } break;
a61af66fc99e Initial load duke parents: diff changeset	879
a61af66fc99e Initial load duke parents: diff changeset	880 case JVM_CONSTANT_ClassIndex:
a61af66fc99e Initial load duke parents: diff changeset	881 {
a61af66fc99e Initial load duke parents: diff changeset	882 int recur1 = klass_index_at(index1);
a61af66fc99e Initial load duke parents: diff changeset	883 int recur2 = cp2->klass_index_at(index2);
a61af66fc99e Initial load duke parents: diff changeset	884 bool match = compare_entry_to(recur1, cp2, recur2, CHECK_false);
a61af66fc99e Initial load duke parents: diff changeset	885 if (match) {
a61af66fc99e Initial load duke parents: diff changeset	886 return true;
a61af66fc99e Initial load duke parents: diff changeset	887 }
a61af66fc99e Initial load duke parents: diff changeset	888 } break;
a61af66fc99e Initial load duke parents: diff changeset	889
a61af66fc99e Initial load duke parents: diff changeset	890 case JVM_CONSTANT_Double:
a61af66fc99e Initial load duke parents: diff changeset	891 {
a61af66fc99e Initial load duke parents: diff changeset	892 jdouble d1 = double_at(index1);
a61af66fc99e Initial load duke parents: diff changeset	893 jdouble d2 = cp2->double_at(index2);
a61af66fc99e Initial load duke parents: diff changeset	894 if (d1 == d2) {
a61af66fc99e Initial load duke parents: diff changeset	895 return true;
a61af66fc99e Initial load duke parents: diff changeset	896 }
a61af66fc99e Initial load duke parents: diff changeset	897 } break;
a61af66fc99e Initial load duke parents: diff changeset	898
a61af66fc99e Initial load duke parents: diff changeset	899 case JVM_CONSTANT_Fieldref:
a61af66fc99e Initial load duke parents: diff changeset	900 case JVM_CONSTANT_InterfaceMethodref:
a61af66fc99e Initial load duke parents: diff changeset	901 case JVM_CONSTANT_Methodref:
a61af66fc99e Initial load duke parents: diff changeset	902 {
a61af66fc99e Initial load duke parents: diff changeset	903 int recur1 = uncached_klass_ref_index_at(index1);
a61af66fc99e Initial load duke parents: diff changeset	904 int recur2 = cp2->uncached_klass_ref_index_at(index2);
a61af66fc99e Initial load duke parents: diff changeset	905 bool match = compare_entry_to(recur1, cp2, recur2, CHECK_false);
a61af66fc99e Initial load duke parents: diff changeset	906 if (match) {
a61af66fc99e Initial load duke parents: diff changeset	907 recur1 = uncached_name_and_type_ref_index_at(index1);
a61af66fc99e Initial load duke parents: diff changeset	908 recur2 = cp2->uncached_name_and_type_ref_index_at(index2);
a61af66fc99e Initial load duke parents: diff changeset	909 match = compare_entry_to(recur1, cp2, recur2, CHECK_false);
a61af66fc99e Initial load duke parents: diff changeset	910 if (match) {
a61af66fc99e Initial load duke parents: diff changeset	911 return true;
a61af66fc99e Initial load duke parents: diff changeset	912 }
a61af66fc99e Initial load duke parents: diff changeset	913 }
a61af66fc99e Initial load duke parents: diff changeset	914 } break;
a61af66fc99e Initial load duke parents: diff changeset	915
a61af66fc99e Initial load duke parents: diff changeset	916 case JVM_CONSTANT_Float:
a61af66fc99e Initial load duke parents: diff changeset	917 {
a61af66fc99e Initial load duke parents: diff changeset	918 jfloat f1 = float_at(index1);
a61af66fc99e Initial load duke parents: diff changeset	919 jfloat f2 = cp2->float_at(index2);
a61af66fc99e Initial load duke parents: diff changeset	920 if (f1 == f2) {
a61af66fc99e Initial load duke parents: diff changeset	921 return true;
a61af66fc99e Initial load duke parents: diff changeset	922 }
a61af66fc99e Initial load duke parents: diff changeset	923 } break;
a61af66fc99e Initial load duke parents: diff changeset	924
a61af66fc99e Initial load duke parents: diff changeset	925 case JVM_CONSTANT_Integer:
a61af66fc99e Initial load duke parents: diff changeset	926 {
a61af66fc99e Initial load duke parents: diff changeset	927 jint i1 = int_at(index1);
a61af66fc99e Initial load duke parents: diff changeset	928 jint i2 = cp2->int_at(index2);
a61af66fc99e Initial load duke parents: diff changeset	929 if (i1 == i2) {
a61af66fc99e Initial load duke parents: diff changeset	930 return true;
a61af66fc99e Initial load duke parents: diff changeset	931 }
a61af66fc99e Initial load duke parents: diff changeset	932 } break;
a61af66fc99e Initial load duke parents: diff changeset	933
a61af66fc99e Initial load duke parents: diff changeset	934 case JVM_CONSTANT_Long:
a61af66fc99e Initial load duke parents: diff changeset	935 {
a61af66fc99e Initial load duke parents: diff changeset	936 jlong l1 = long_at(index1);
a61af66fc99e Initial load duke parents: diff changeset	937 jlong l2 = cp2->long_at(index2);
a61af66fc99e Initial load duke parents: diff changeset	938 if (l1 == l2) {
a61af66fc99e Initial load duke parents: diff changeset	939 return true;
a61af66fc99e Initial load duke parents: diff changeset	940 }
a61af66fc99e Initial load duke parents: diff changeset	941 } break;
a61af66fc99e Initial load duke parents: diff changeset	942
a61af66fc99e Initial load duke parents: diff changeset	943 case JVM_CONSTANT_NameAndType:
a61af66fc99e Initial load duke parents: diff changeset	944 {
a61af66fc99e Initial load duke parents: diff changeset	945 int recur1 = name_ref_index_at(index1);
a61af66fc99e Initial load duke parents: diff changeset	946 int recur2 = cp2->name_ref_index_at(index2);
a61af66fc99e Initial load duke parents: diff changeset	947 bool match = compare_entry_to(recur1, cp2, recur2, CHECK_false);
a61af66fc99e Initial load duke parents: diff changeset	948 if (match) {
a61af66fc99e Initial load duke parents: diff changeset	949 recur1 = signature_ref_index_at(index1);
a61af66fc99e Initial load duke parents: diff changeset	950 recur2 = cp2->signature_ref_index_at(index2);
a61af66fc99e Initial load duke parents: diff changeset	951 match = compare_entry_to(recur1, cp2, recur2, CHECK_false);
a61af66fc99e Initial load duke parents: diff changeset	952 if (match) {
a61af66fc99e Initial load duke parents: diff changeset	953 return true;
a61af66fc99e Initial load duke parents: diff changeset	954 }
a61af66fc99e Initial load duke parents: diff changeset	955 }
a61af66fc99e Initial load duke parents: diff changeset	956 } break;
a61af66fc99e Initial load duke parents: diff changeset	957
a61af66fc99e Initial load duke parents: diff changeset	958 case JVM_CONSTANT_StringIndex:
a61af66fc99e Initial load duke parents: diff changeset	959 {
a61af66fc99e Initial load duke parents: diff changeset	960 int recur1 = string_index_at(index1);
a61af66fc99e Initial load duke parents: diff changeset	961 int recur2 = cp2->string_index_at(index2);
a61af66fc99e Initial load duke parents: diff changeset	962 bool match = compare_entry_to(recur1, cp2, recur2, CHECK_false);
a61af66fc99e Initial load duke parents: diff changeset	963 if (match) {
a61af66fc99e Initial load duke parents: diff changeset	964 return true;
a61af66fc99e Initial load duke parents: diff changeset	965 }
a61af66fc99e Initial load duke parents: diff changeset	966 } break;
a61af66fc99e Initial load duke parents: diff changeset	967
a61af66fc99e Initial load duke parents: diff changeset	968 case JVM_CONSTANT_UnresolvedClass:
a61af66fc99e Initial load duke parents: diff changeset	969 {
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	970 Symbol* k1 = unresolved_klass_at(index1);
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	971 Symbol* k2 = cp2->unresolved_klass_at(index2);
0 a61af66fc99e Initial load duke parents: diff changeset	972 if (k1 == k2) {
a61af66fc99e Initial load duke parents: diff changeset	973 return true;
a61af66fc99e Initial load duke parents: diff changeset	974 }
a61af66fc99e Initial load duke parents: diff changeset	975 } break;
a61af66fc99e Initial load duke parents: diff changeset	976
1602 136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	977 case JVM_CONSTANT_MethodType:
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	978 {
12845 b4a4fdc1f464 8025185: MethodHandleInError and MethodTypeInError not handled in ConstantPool::compare_entry_to and copy_entry_to coleenp parents: 12316 diff changeset	979 int k1 = method_type_index_at_error_ok(index1);
b4a4fdc1f464 8025185: MethodHandleInError and MethodTypeInError not handled in ConstantPool::compare_entry_to and copy_entry_to coleenp parents: 12316 diff changeset	980 int k2 = cp2->method_type_index_at_error_ok(index2);
2011 dad31fc330cd 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute jrose parents: 1972 diff changeset	981 bool match = compare_entry_to(k1, cp2, k2, CHECK_false);
dad31fc330cd 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute jrose parents: 1972 diff changeset	982 if (match) {
1602 136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	983 return true;
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	984 }
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	985 } break;
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	986
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	987 case JVM_CONSTANT_MethodHandle:
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	988 {
12845 b4a4fdc1f464 8025185: MethodHandleInError and MethodTypeInError not handled in ConstantPool::compare_entry_to and copy_entry_to coleenp parents: 12316 diff changeset	989 int k1 = method_handle_ref_kind_at_error_ok(index1);
b4a4fdc1f464 8025185: MethodHandleInError and MethodTypeInError not handled in ConstantPool::compare_entry_to and copy_entry_to coleenp parents: 12316 diff changeset	990 int k2 = cp2->method_handle_ref_kind_at_error_ok(index2);
1602 136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	991 if (k1 == k2) {
12845 b4a4fdc1f464 8025185: MethodHandleInError and MethodTypeInError not handled in ConstantPool::compare_entry_to and copy_entry_to coleenp parents: 12316 diff changeset	992 int i1 = method_handle_index_at_error_ok(index1);
b4a4fdc1f464 8025185: MethodHandleInError and MethodTypeInError not handled in ConstantPool::compare_entry_to and copy_entry_to coleenp parents: 12316 diff changeset	993 int i2 = cp2->method_handle_index_at_error_ok(index2);
2011 dad31fc330cd 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute jrose parents: 1972 diff changeset	994 bool match = compare_entry_to(i1, cp2, i2, CHECK_false);
dad31fc330cd 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute jrose parents: 1972 diff changeset	995 if (match) {
1602 136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	996 return true;
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	997 }
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	998 }
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	999 } break;
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	1000
1660 083fde3b838e 6964498: JSR 292 invokedynamic sites need local bootstrap methods jrose parents: 1602 diff changeset	1001 case JVM_CONSTANT_InvokeDynamic:
083fde3b838e 6964498: JSR 292 invokedynamic sites need local bootstrap methods jrose parents: 1602 diff changeset	1002 {
10151 15a99ca4ee34 8007037: JSR 292: the VM_RedefineClasses::append_entry() should do cross-checks with indy operands sspitsyn parents: 9060 diff changeset	1003 int k1 = invoke_dynamic_name_and_type_ref_index_at(index1);
15a99ca4ee34 8007037: JSR 292: the VM_RedefineClasses::append_entry() should do cross-checks with indy operands sspitsyn parents: 9060 diff changeset	1004 int k2 = cp2->invoke_dynamic_name_and_type_ref_index_at(index2);
15a99ca4ee34 8007037: JSR 292: the VM_RedefineClasses::append_entry() should do cross-checks with indy operands sspitsyn parents: 9060 diff changeset	1005 int i1 = invoke_dynamic_bootstrap_specifier_index(index1);
15a99ca4ee34 8007037: JSR 292: the VM_RedefineClasses::append_entry() should do cross-checks with indy operands sspitsyn parents: 9060 diff changeset	1006 int i2 = cp2->invoke_dynamic_bootstrap_specifier_index(index2);
10350 51af5fae397d 8015265: revise the fix for 8007037 ccheung parents: 10152 diff changeset	1007 // separate statements and variables because CHECK_false is used
51af5fae397d 8015265: revise the fix for 8007037 ccheung parents: 10152 diff changeset	1008 bool match_entry = compare_entry_to(k1, cp2, k2, CHECK_false);
51af5fae397d 8015265: revise the fix for 8007037 ccheung parents: 10152 diff changeset	1009 bool match_operand = compare_operand_to(i1, cp2, i2, CHECK_false);
51af5fae397d 8015265: revise the fix for 8007037 ccheung parents: 10152 diff changeset	1010 return (match_entry && match_operand);
1660 083fde3b838e 6964498: JSR 292 invokedynamic sites need local bootstrap methods jrose parents: 1602 diff changeset	1011 } break;
083fde3b838e 6964498: JSR 292 invokedynamic sites need local bootstrap methods jrose parents: 1602 diff changeset	1012
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1013 case JVM_CONSTANT_String:
0 a61af66fc99e Initial load duke parents: diff changeset	1014 {
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	1015 Symbol* s1 = unresolved_string_at(index1);
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	1016 Symbol* s2 = cp2->unresolved_string_at(index2);
0 a61af66fc99e Initial load duke parents: diff changeset	1017 if (s1 == s2) {
a61af66fc99e Initial load duke parents: diff changeset	1018 return true;
a61af66fc99e Initial load duke parents: diff changeset	1019 }
a61af66fc99e Initial load duke parents: diff changeset	1020 } break;
a61af66fc99e Initial load duke parents: diff changeset	1021
a61af66fc99e Initial load duke parents: diff changeset	1022 case JVM_CONSTANT_Utf8:
a61af66fc99e Initial load duke parents: diff changeset	1023 {
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	1024 Symbol* s1 = symbol_at(index1);
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	1025 Symbol* s2 = cp2->symbol_at(index2);
0 a61af66fc99e Initial load duke parents: diff changeset	1026 if (s1 == s2) {
a61af66fc99e Initial load duke parents: diff changeset	1027 return true;
a61af66fc99e Initial load duke parents: diff changeset	1028 }
a61af66fc99e Initial load duke parents: diff changeset	1029 } break;
a61af66fc99e Initial load duke parents: diff changeset	1030
a61af66fc99e Initial load duke parents: diff changeset	1031 // Invalid is used as the tag for the second constant pool entry
a61af66fc99e Initial load duke parents: diff changeset	1032 // occupied by JVM_CONSTANT_Double or JVM_CONSTANT_Long. It should
a61af66fc99e Initial load duke parents: diff changeset	1033 // not be seen by itself.
a61af66fc99e Initial load duke parents: diff changeset	1034 case JVM_CONSTANT_Invalid: // fall through
a61af66fc99e Initial load duke parents: diff changeset	1035
a61af66fc99e Initial load duke parents: diff changeset	1036 default:
a61af66fc99e Initial load duke parents: diff changeset	1037 ShouldNotReachHere();
a61af66fc99e Initial load duke parents: diff changeset	1038 break;
a61af66fc99e Initial load duke parents: diff changeset	1039 }
a61af66fc99e Initial load duke parents: diff changeset	1040
a61af66fc99e Initial load duke parents: diff changeset	1041 return false;
a61af66fc99e Initial load duke parents: diff changeset	1042 } // end compare_entry_to()
a61af66fc99e Initial load duke parents: diff changeset	1043
a61af66fc99e Initial load duke parents: diff changeset	1044
10151 15a99ca4ee34 8007037: JSR 292: the VM_RedefineClasses::append_entry() should do cross-checks with indy operands sspitsyn parents: 9060 diff changeset	1045 // Resize the operands array with delta_len and delta_size.
15a99ca4ee34 8007037: JSR 292: the VM_RedefineClasses::append_entry() should do cross-checks with indy operands sspitsyn parents: 9060 diff changeset	1046 // Used in RedefineClasses for CP merge.
15a99ca4ee34 8007037: JSR 292: the VM_RedefineClasses::append_entry() should do cross-checks with indy operands sspitsyn parents: 9060 diff changeset	1047 void ConstantPool::resize_operands(int delta_len, int delta_size, TRAPS) {
15a99ca4ee34 8007037: JSR 292: the VM_RedefineClasses::append_entry() should do cross-checks with indy operands sspitsyn parents: 9060 diff changeset	1048 int old_len = operand_array_length(operands());
15a99ca4ee34 8007037: JSR 292: the VM_RedefineClasses::append_entry() should do cross-checks with indy operands sspitsyn parents: 9060 diff changeset	1049 int new_len = old_len + delta_len;
15a99ca4ee34 8007037: JSR 292: the VM_RedefineClasses::append_entry() should do cross-checks with indy operands sspitsyn parents: 9060 diff changeset	1050 int min_len = (delta_len > 0) ? old_len : new_len;
15a99ca4ee34 8007037: JSR 292: the VM_RedefineClasses::append_entry() should do cross-checks with indy operands sspitsyn parents: 9060 diff changeset	1051
15a99ca4ee34 8007037: JSR 292: the VM_RedefineClasses::append_entry() should do cross-checks with indy operands sspitsyn parents: 9060 diff changeset	1052 int old_size = operands()->length();
15a99ca4ee34 8007037: JSR 292: the VM_RedefineClasses::append_entry() should do cross-checks with indy operands sspitsyn parents: 9060 diff changeset	1053 int new_size = old_size + delta_size;
15a99ca4ee34 8007037: JSR 292: the VM_RedefineClasses::append_entry() should do cross-checks with indy operands sspitsyn parents: 9060 diff changeset	1054 int min_size = (delta_size > 0) ? old_size : new_size;
15a99ca4ee34 8007037: JSR 292: the VM_RedefineClasses::append_entry() should do cross-checks with indy operands sspitsyn parents: 9060 diff changeset	1055
15a99ca4ee34 8007037: JSR 292: the VM_RedefineClasses::append_entry() should do cross-checks with indy operands sspitsyn parents: 9060 diff changeset	1056 ClassLoaderData* loader_data = pool_holder()->class_loader_data();
15a99ca4ee34 8007037: JSR 292: the VM_RedefineClasses::append_entry() should do cross-checks with indy operands sspitsyn parents: 9060 diff changeset	1057 Array<u2>* new_ops = MetadataFactory::new_array<u2>(loader_data, new_size, CHECK);
15a99ca4ee34 8007037: JSR 292: the VM_RedefineClasses::append_entry() should do cross-checks with indy operands sspitsyn parents: 9060 diff changeset	1058
15a99ca4ee34 8007037: JSR 292: the VM_RedefineClasses::append_entry() should do cross-checks with indy operands sspitsyn parents: 9060 diff changeset	1059 // Set index in the resized array for existing elements only
15a99ca4ee34 8007037: JSR 292: the VM_RedefineClasses::append_entry() should do cross-checks with indy operands sspitsyn parents: 9060 diff changeset	1060 for (int idx = 0; idx < min_len; idx++) {
15a99ca4ee34 8007037: JSR 292: the VM_RedefineClasses::append_entry() should do cross-checks with indy operands sspitsyn parents: 9060 diff changeset	1061 int offset = operand_offset_at(idx); // offset in original array
15a99ca4ee34 8007037: JSR 292: the VM_RedefineClasses::append_entry() should do cross-checks with indy operands sspitsyn parents: 9060 diff changeset	1062 operand_offset_at_put(new_ops, idx, offset + 2*delta_len); // offset in resized array
15a99ca4ee34 8007037: JSR 292: the VM_RedefineClasses::append_entry() should do cross-checks with indy operands sspitsyn parents: 9060 diff changeset	1063 }
15a99ca4ee34 8007037: JSR 292: the VM_RedefineClasses::append_entry() should do cross-checks with indy operands sspitsyn parents: 9060 diff changeset	1064 // Copy the bootstrap specifiers only
15a99ca4ee34 8007037: JSR 292: the VM_RedefineClasses::append_entry() should do cross-checks with indy operands sspitsyn parents: 9060 diff changeset	1065 Copy::conjoint_memory_atomic(operands()->adr_at(2*old_len),
15a99ca4ee34 8007037: JSR 292: the VM_RedefineClasses::append_entry() should do cross-checks with indy operands sspitsyn parents: 9060 diff changeset	1066 new_ops->adr_at(2*new_len),
15a99ca4ee34 8007037: JSR 292: the VM_RedefineClasses::append_entry() should do cross-checks with indy operands sspitsyn parents: 9060 diff changeset	1067 (min_size - 2min_len) sizeof(u2));
15a99ca4ee34 8007037: JSR 292: the VM_RedefineClasses::append_entry() should do cross-checks with indy operands sspitsyn parents: 9060 diff changeset	1068 // Explicitly deallocate old operands array.
15a99ca4ee34 8007037: JSR 292: the VM_RedefineClasses::append_entry() should do cross-checks with indy operands sspitsyn parents: 9060 diff changeset	1069 // Note, it is not needed for 7u backport.
15a99ca4ee34 8007037: JSR 292: the VM_RedefineClasses::append_entry() should do cross-checks with indy operands sspitsyn parents: 9060 diff changeset	1070 if ( operands() != NULL) { // the safety check
15a99ca4ee34 8007037: JSR 292: the VM_RedefineClasses::append_entry() should do cross-checks with indy operands sspitsyn parents: 9060 diff changeset	1071 MetadataFactory::free_array<u2>(loader_data, operands());
15a99ca4ee34 8007037: JSR 292: the VM_RedefineClasses::append_entry() should do cross-checks with indy operands sspitsyn parents: 9060 diff changeset	1072 }
15a99ca4ee34 8007037: JSR 292: the VM_RedefineClasses::append_entry() should do cross-checks with indy operands sspitsyn parents: 9060 diff changeset	1073 set_operands(new_ops);
15a99ca4ee34 8007037: JSR 292: the VM_RedefineClasses::append_entry() should do cross-checks with indy operands sspitsyn parents: 9060 diff changeset	1074 } // end resize_operands()
15a99ca4ee34 8007037: JSR 292: the VM_RedefineClasses::append_entry() should do cross-checks with indy operands sspitsyn parents: 9060 diff changeset	1075
15a99ca4ee34 8007037: JSR 292: the VM_RedefineClasses::append_entry() should do cross-checks with indy operands sspitsyn parents: 9060 diff changeset	1076
15a99ca4ee34 8007037: JSR 292: the VM_RedefineClasses::append_entry() should do cross-checks with indy operands sspitsyn parents: 9060 diff changeset	1077 // Extend the operands array with the length and size of the ext_cp operands.
15a99ca4ee34 8007037: JSR 292: the VM_RedefineClasses::append_entry() should do cross-checks with indy operands sspitsyn parents: 9060 diff changeset	1078 // Used in RedefineClasses for CP merge.
15a99ca4ee34 8007037: JSR 292: the VM_RedefineClasses::append_entry() should do cross-checks with indy operands sspitsyn parents: 9060 diff changeset	1079 void ConstantPool::extend_operands(constantPoolHandle ext_cp, TRAPS) {
15a99ca4ee34 8007037: JSR 292: the VM_RedefineClasses::append_entry() should do cross-checks with indy operands sspitsyn parents: 9060 diff changeset	1080 int delta_len = operand_array_length(ext_cp->operands());
15a99ca4ee34 8007037: JSR 292: the VM_RedefineClasses::append_entry() should do cross-checks with indy operands sspitsyn parents: 9060 diff changeset	1081 if (delta_len == 0) {
15a99ca4ee34 8007037: JSR 292: the VM_RedefineClasses::append_entry() should do cross-checks with indy operands sspitsyn parents: 9060 diff changeset	1082 return; // nothing to do
15a99ca4ee34 8007037: JSR 292: the VM_RedefineClasses::append_entry() should do cross-checks with indy operands sspitsyn parents: 9060 diff changeset	1083 }
15a99ca4ee34 8007037: JSR 292: the VM_RedefineClasses::append_entry() should do cross-checks with indy operands sspitsyn parents: 9060 diff changeset	1084 int delta_size = ext_cp->operands()->length();
15a99ca4ee34 8007037: JSR 292: the VM_RedefineClasses::append_entry() should do cross-checks with indy operands sspitsyn parents: 9060 diff changeset	1085
15a99ca4ee34 8007037: JSR 292: the VM_RedefineClasses::append_entry() should do cross-checks with indy operands sspitsyn parents: 9060 diff changeset	1086 assert(delta_len > 0 && delta_size > 0, "extended operands array must be bigger");
15a99ca4ee34 8007037: JSR 292: the VM_RedefineClasses::append_entry() should do cross-checks with indy operands sspitsyn parents: 9060 diff changeset	1087
15a99ca4ee34 8007037: JSR 292: the VM_RedefineClasses::append_entry() should do cross-checks with indy operands sspitsyn parents: 9060 diff changeset	1088 if (operand_array_length(operands()) == 0) {
15a99ca4ee34 8007037: JSR 292: the VM_RedefineClasses::append_entry() should do cross-checks with indy operands sspitsyn parents: 9060 diff changeset	1089 ClassLoaderData* loader_data = pool_holder()->class_loader_data();
15a99ca4ee34 8007037: JSR 292: the VM_RedefineClasses::append_entry() should do cross-checks with indy operands sspitsyn parents: 9060 diff changeset	1090 Array<u2>* new_ops = MetadataFactory::new_array<u2>(loader_data, delta_size, CHECK);
15a99ca4ee34 8007037: JSR 292: the VM_RedefineClasses::append_entry() should do cross-checks with indy operands sspitsyn parents: 9060 diff changeset	1091 // The first element index defines the offset of second part
15a99ca4ee34 8007037: JSR 292: the VM_RedefineClasses::append_entry() should do cross-checks with indy operands sspitsyn parents: 9060 diff changeset	1092 operand_offset_at_put(new_ops, 0, 2*delta_len); // offset in new array
15a99ca4ee34 8007037: JSR 292: the VM_RedefineClasses::append_entry() should do cross-checks with indy operands sspitsyn parents: 9060 diff changeset	1093 set_operands(new_ops);
15a99ca4ee34 8007037: JSR 292: the VM_RedefineClasses::append_entry() should do cross-checks with indy operands sspitsyn parents: 9060 diff changeset	1094 } else {
15a99ca4ee34 8007037: JSR 292: the VM_RedefineClasses::append_entry() should do cross-checks with indy operands sspitsyn parents: 9060 diff changeset	1095 resize_operands(delta_len, delta_size, CHECK);
15a99ca4ee34 8007037: JSR 292: the VM_RedefineClasses::append_entry() should do cross-checks with indy operands sspitsyn parents: 9060 diff changeset	1096 }
15a99ca4ee34 8007037: JSR 292: the VM_RedefineClasses::append_entry() should do cross-checks with indy operands sspitsyn parents: 9060 diff changeset	1097
15a99ca4ee34 8007037: JSR 292: the VM_RedefineClasses::append_entry() should do cross-checks with indy operands sspitsyn parents: 9060 diff changeset	1098 } // end extend_operands()
15a99ca4ee34 8007037: JSR 292: the VM_RedefineClasses::append_entry() should do cross-checks with indy operands sspitsyn parents: 9060 diff changeset	1099
15a99ca4ee34 8007037: JSR 292: the VM_RedefineClasses::append_entry() should do cross-checks with indy operands sspitsyn parents: 9060 diff changeset	1100
15a99ca4ee34 8007037: JSR 292: the VM_RedefineClasses::append_entry() should do cross-checks with indy operands sspitsyn parents: 9060 diff changeset	1101 // Shrink the operands array to a smaller array with new_len length.
15a99ca4ee34 8007037: JSR 292: the VM_RedefineClasses::append_entry() should do cross-checks with indy operands sspitsyn parents: 9060 diff changeset	1102 // Used in RedefineClasses for CP merge.
15a99ca4ee34 8007037: JSR 292: the VM_RedefineClasses::append_entry() should do cross-checks with indy operands sspitsyn parents: 9060 diff changeset	1103 void ConstantPool::shrink_operands(int new_len, TRAPS) {
15a99ca4ee34 8007037: JSR 292: the VM_RedefineClasses::append_entry() should do cross-checks with indy operands sspitsyn parents: 9060 diff changeset	1104 int old_len = operand_array_length(operands());
15a99ca4ee34 8007037: JSR 292: the VM_RedefineClasses::append_entry() should do cross-checks with indy operands sspitsyn parents: 9060 diff changeset	1105 if (new_len == old_len) {
15a99ca4ee34 8007037: JSR 292: the VM_RedefineClasses::append_entry() should do cross-checks with indy operands sspitsyn parents: 9060 diff changeset	1106 return; // nothing to do
15a99ca4ee34 8007037: JSR 292: the VM_RedefineClasses::append_entry() should do cross-checks with indy operands sspitsyn parents: 9060 diff changeset	1107 }
15a99ca4ee34 8007037: JSR 292: the VM_RedefineClasses::append_entry() should do cross-checks with indy operands sspitsyn parents: 9060 diff changeset	1108 assert(new_len < old_len, "shrunken operands array must be smaller");
15a99ca4ee34 8007037: JSR 292: the VM_RedefineClasses::append_entry() should do cross-checks with indy operands sspitsyn parents: 9060 diff changeset	1109
15a99ca4ee34 8007037: JSR 292: the VM_RedefineClasses::append_entry() should do cross-checks with indy operands sspitsyn parents: 9060 diff changeset	1110 int free_base = operand_next_offset_at(new_len - 1);
15a99ca4ee34 8007037: JSR 292: the VM_RedefineClasses::append_entry() should do cross-checks with indy operands sspitsyn parents: 9060 diff changeset	1111 int delta_len = new_len - old_len;
15a99ca4ee34 8007037: JSR 292: the VM_RedefineClasses::append_entry() should do cross-checks with indy operands sspitsyn parents: 9060 diff changeset	1112 int delta_size = 2*delta_len + free_base - operands()->length();
15a99ca4ee34 8007037: JSR 292: the VM_RedefineClasses::append_entry() should do cross-checks with indy operands sspitsyn parents: 9060 diff changeset	1113
15a99ca4ee34 8007037: JSR 292: the VM_RedefineClasses::append_entry() should do cross-checks with indy operands sspitsyn parents: 9060 diff changeset	1114 resize_operands(delta_len, delta_size, CHECK);
15a99ca4ee34 8007037: JSR 292: the VM_RedefineClasses::append_entry() should do cross-checks with indy operands sspitsyn parents: 9060 diff changeset	1115
15a99ca4ee34 8007037: JSR 292: the VM_RedefineClasses::append_entry() should do cross-checks with indy operands sspitsyn parents: 9060 diff changeset	1116 } // end shrink_operands()
15a99ca4ee34 8007037: JSR 292: the VM_RedefineClasses::append_entry() should do cross-checks with indy operands sspitsyn parents: 9060 diff changeset	1117
15a99ca4ee34 8007037: JSR 292: the VM_RedefineClasses::append_entry() should do cross-checks with indy operands sspitsyn parents: 9060 diff changeset	1118
7952 edd76a5856f7 8005128: JSR 292: the mlvm redefineClassInBootstrap test crashes in ConstantPool::compare_entry_to sspitsyn parents: 7949 diff changeset	1119 void ConstantPool::copy_operands(constantPoolHandle from_cp,
edd76a5856f7 8005128: JSR 292: the mlvm redefineClassInBootstrap test crashes in ConstantPool::compare_entry_to sspitsyn parents: 7949 diff changeset	1120 constantPoolHandle to_cp,
edd76a5856f7 8005128: JSR 292: the mlvm redefineClassInBootstrap test crashes in ConstantPool::compare_entry_to sspitsyn parents: 7949 diff changeset	1121 TRAPS) {
2011 dad31fc330cd 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute jrose parents: 1972 diff changeset	1122
dad31fc330cd 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute jrose parents: 1972 diff changeset	1123 int from_oplen = operand_array_length(from_cp->operands());
dad31fc330cd 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute jrose parents: 1972 diff changeset	1124 int old_oplen = operand_array_length(to_cp->operands());
dad31fc330cd 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute jrose parents: 1972 diff changeset	1125 if (from_oplen != 0) {
6934 4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6840 diff changeset	1126 ClassLoaderData* loader_data = to_cp->pool_holder()->class_loader_data();
2011 dad31fc330cd 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute jrose parents: 1972 diff changeset	1127 // append my operands to the target's operands array
dad31fc330cd 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute jrose parents: 1972 diff changeset	1128 if (old_oplen == 0) {
6934 4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6840 diff changeset	1129 // Can't just reuse from_cp's operand list because of deallocation issues
4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6840 diff changeset	1130 int len = from_cp->operands()->length();
4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6840 diff changeset	1131 Array<u2>* new_ops = MetadataFactory::new_array<u2>(loader_data, len, CHECK);
4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6840 diff changeset	1132 Copy::conjoint_memory_atomic(
4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6840 diff changeset	1133 from_cp->operands()->adr_at(0), new_ops->adr_at(0), len * sizeof(u2));
4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6840 diff changeset	1134 to_cp->set_operands(new_ops);
2011 dad31fc330cd 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute jrose parents: 1972 diff changeset	1135 } else {
dad31fc330cd 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute jrose parents: 1972 diff changeset	1136 int old_len = to_cp->operands()->length();
dad31fc330cd 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute jrose parents: 1972 diff changeset	1137 int from_len = from_cp->operands()->length();
dad31fc330cd 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute jrose parents: 1972 diff changeset	1138 int old_off = old_oplen * sizeof(u2);
dad31fc330cd 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute jrose parents: 1972 diff changeset	1139 int from_off = from_oplen * sizeof(u2);
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1140 // Use the metaspace for the destination constant pool
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1141 Array<u2>* new_operands = MetadataFactory::new_array<u2>(loader_data, old_len + from_len, CHECK);
2011 dad31fc330cd 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute jrose parents: 1972 diff changeset	1142 int fillp = 0, len = 0;
dad31fc330cd 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute jrose parents: 1972 diff changeset	1143 // first part of dest
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1144 Copy::conjoint_memory_atomic(to_cp->operands()->adr_at(0),
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1145 new_operands->adr_at(fillp),
2011 dad31fc330cd 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute jrose parents: 1972 diff changeset	1146 (len = old_off) * sizeof(u2));
dad31fc330cd 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute jrose parents: 1972 diff changeset	1147 fillp += len;
dad31fc330cd 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute jrose parents: 1972 diff changeset	1148 // first part of src
7964 dc31f560d6e7 8006546: JSR 292: typos in the ConstantPool::copy_cp_impl() sspitsyn parents: 7957 diff changeset	1149 Copy::conjoint_memory_atomic(from_cp->operands()->adr_at(0),
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1150 new_operands->adr_at(fillp),
2011 dad31fc330cd 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute jrose parents: 1972 diff changeset	1151 (len = from_off) * sizeof(u2));
dad31fc330cd 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute jrose parents: 1972 diff changeset	1152 fillp += len;
dad31fc330cd 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute jrose parents: 1972 diff changeset	1153 // second part of dest
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1154 Copy::conjoint_memory_atomic(to_cp->operands()->adr_at(old_off),
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1155 new_operands->adr_at(fillp),
2011 dad31fc330cd 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute jrose parents: 1972 diff changeset	1156 (len = old_len - old_off) * sizeof(u2));
dad31fc330cd 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute jrose parents: 1972 diff changeset	1157 fillp += len;
dad31fc330cd 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute jrose parents: 1972 diff changeset	1158 // second part of src
7964 dc31f560d6e7 8006546: JSR 292: typos in the ConstantPool::copy_cp_impl() sspitsyn parents: 7957 diff changeset	1159 Copy::conjoint_memory_atomic(from_cp->operands()->adr_at(from_off),
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1160 new_operands->adr_at(fillp),
2011 dad31fc330cd 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute jrose parents: 1972 diff changeset	1161 (len = from_len - from_off) * sizeof(u2));
dad31fc330cd 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute jrose parents: 1972 diff changeset	1162 fillp += len;
dad31fc330cd 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute jrose parents: 1972 diff changeset	1163 assert(fillp == new_operands->length(), "");
dad31fc330cd 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute jrose parents: 1972 diff changeset	1164
dad31fc330cd 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute jrose parents: 1972 diff changeset	1165 // Adjust indexes in the first part of the copied operands array.
dad31fc330cd 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute jrose parents: 1972 diff changeset	1166 for (int j = 0; j < from_oplen; j++) {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1167 int offset = operand_offset_at(new_operands, old_oplen + j);
2011 dad31fc330cd 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute jrose parents: 1972 diff changeset	1168 assert(offset == operand_offset_at(from_cp->operands(), j), "correct copy");
dad31fc330cd 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute jrose parents: 1972 diff changeset	1169 offset += old_len; // every new tuple is preceded by old_len extra u2's
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1170 operand_offset_at_put(new_operands, old_oplen + j, offset);
2011 dad31fc330cd 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute jrose parents: 1972 diff changeset	1171 }
dad31fc330cd 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute jrose parents: 1972 diff changeset	1172
dad31fc330cd 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute jrose parents: 1972 diff changeset	1173 // replace target operands array with combined array
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1174 to_cp->set_operands(new_operands);
2011 dad31fc330cd 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute jrose parents: 1972 diff changeset	1175 }
dad31fc330cd 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute jrose parents: 1972 diff changeset	1176 }
7952 edd76a5856f7 8005128: JSR 292: the mlvm redefineClassInBootstrap test crashes in ConstantPool::compare_entry_to sspitsyn parents: 7949 diff changeset	1177 } // end copy_operands()
2011 dad31fc330cd 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute jrose parents: 1972 diff changeset	1178
7952 edd76a5856f7 8005128: JSR 292: the mlvm redefineClassInBootstrap test crashes in ConstantPool::compare_entry_to sspitsyn parents: 7949 diff changeset	1179
edd76a5856f7 8005128: JSR 292: the mlvm redefineClassInBootstrap test crashes in ConstantPool::compare_entry_to sspitsyn parents: 7949 diff changeset	1180 // Copy this constant pool's entries at start_i to end_i (inclusive)
edd76a5856f7 8005128: JSR 292: the mlvm redefineClassInBootstrap test crashes in ConstantPool::compare_entry_to sspitsyn parents: 7949 diff changeset	1181 // to the constant pool to_cp's entries starting at to_i. A total of
edd76a5856f7 8005128: JSR 292: the mlvm redefineClassInBootstrap test crashes in ConstantPool::compare_entry_to sspitsyn parents: 7949 diff changeset	1182 // (end_i - start_i) + 1 entries are copied.
edd76a5856f7 8005128: JSR 292: the mlvm redefineClassInBootstrap test crashes in ConstantPool::compare_entry_to sspitsyn parents: 7949 diff changeset	1183 void ConstantPool::copy_cp_to_impl(constantPoolHandle from_cp, int start_i, int end_i,
edd76a5856f7 8005128: JSR 292: the mlvm redefineClassInBootstrap test crashes in ConstantPool::compare_entry_to sspitsyn parents: 7949 diff changeset	1184 constantPoolHandle to_cp, int to_i, TRAPS) {
edd76a5856f7 8005128: JSR 292: the mlvm redefineClassInBootstrap test crashes in ConstantPool::compare_entry_to sspitsyn parents: 7949 diff changeset	1185
edd76a5856f7 8005128: JSR 292: the mlvm redefineClassInBootstrap test crashes in ConstantPool::compare_entry_to sspitsyn parents: 7949 diff changeset	1186
edd76a5856f7 8005128: JSR 292: the mlvm redefineClassInBootstrap test crashes in ConstantPool::compare_entry_to sspitsyn parents: 7949 diff changeset	1187 int dest_i = to_i; // leave original alone for debug purposes
edd76a5856f7 8005128: JSR 292: the mlvm redefineClassInBootstrap test crashes in ConstantPool::compare_entry_to sspitsyn parents: 7949 diff changeset	1188
edd76a5856f7 8005128: JSR 292: the mlvm redefineClassInBootstrap test crashes in ConstantPool::compare_entry_to sspitsyn parents: 7949 diff changeset	1189 for (int src_i = start_i; src_i <= end_i; /* see loop bottom */ ) {
edd76a5856f7 8005128: JSR 292: the mlvm redefineClassInBootstrap test crashes in ConstantPool::compare_entry_to sspitsyn parents: 7949 diff changeset	1190 copy_entry_to(from_cp, src_i, to_cp, dest_i, CHECK);
edd76a5856f7 8005128: JSR 292: the mlvm redefineClassInBootstrap test crashes in ConstantPool::compare_entry_to sspitsyn parents: 7949 diff changeset	1191
edd76a5856f7 8005128: JSR 292: the mlvm redefineClassInBootstrap test crashes in ConstantPool::compare_entry_to sspitsyn parents: 7949 diff changeset	1192 switch (from_cp->tag_at(src_i).value()) {
edd76a5856f7 8005128: JSR 292: the mlvm redefineClassInBootstrap test crashes in ConstantPool::compare_entry_to sspitsyn parents: 7949 diff changeset	1193 case JVM_CONSTANT_Double:
edd76a5856f7 8005128: JSR 292: the mlvm redefineClassInBootstrap test crashes in ConstantPool::compare_entry_to sspitsyn parents: 7949 diff changeset	1194 case JVM_CONSTANT_Long:
edd76a5856f7 8005128: JSR 292: the mlvm redefineClassInBootstrap test crashes in ConstantPool::compare_entry_to sspitsyn parents: 7949 diff changeset	1195 // double and long take two constant pool entries
edd76a5856f7 8005128: JSR 292: the mlvm redefineClassInBootstrap test crashes in ConstantPool::compare_entry_to sspitsyn parents: 7949 diff changeset	1196 src_i += 2;
edd76a5856f7 8005128: JSR 292: the mlvm redefineClassInBootstrap test crashes in ConstantPool::compare_entry_to sspitsyn parents: 7949 diff changeset	1197 dest_i += 2;
edd76a5856f7 8005128: JSR 292: the mlvm redefineClassInBootstrap test crashes in ConstantPool::compare_entry_to sspitsyn parents: 7949 diff changeset	1198 break;
edd76a5856f7 8005128: JSR 292: the mlvm redefineClassInBootstrap test crashes in ConstantPool::compare_entry_to sspitsyn parents: 7949 diff changeset	1199
edd76a5856f7 8005128: JSR 292: the mlvm redefineClassInBootstrap test crashes in ConstantPool::compare_entry_to sspitsyn parents: 7949 diff changeset	1200 default:
edd76a5856f7 8005128: JSR 292: the mlvm redefineClassInBootstrap test crashes in ConstantPool::compare_entry_to sspitsyn parents: 7949 diff changeset	1201 // all others take one constant pool entry
edd76a5856f7 8005128: JSR 292: the mlvm redefineClassInBootstrap test crashes in ConstantPool::compare_entry_to sspitsyn parents: 7949 diff changeset	1202 src_i++;
edd76a5856f7 8005128: JSR 292: the mlvm redefineClassInBootstrap test crashes in ConstantPool::compare_entry_to sspitsyn parents: 7949 diff changeset	1203 dest_i++;
edd76a5856f7 8005128: JSR 292: the mlvm redefineClassInBootstrap test crashes in ConstantPool::compare_entry_to sspitsyn parents: 7949 diff changeset	1204 break;
edd76a5856f7 8005128: JSR 292: the mlvm redefineClassInBootstrap test crashes in ConstantPool::compare_entry_to sspitsyn parents: 7949 diff changeset	1205 }
edd76a5856f7 8005128: JSR 292: the mlvm redefineClassInBootstrap test crashes in ConstantPool::compare_entry_to sspitsyn parents: 7949 diff changeset	1206 }
edd76a5856f7 8005128: JSR 292: the mlvm redefineClassInBootstrap test crashes in ConstantPool::compare_entry_to sspitsyn parents: 7949 diff changeset	1207 copy_operands(from_cp, to_cp, CHECK);
edd76a5856f7 8005128: JSR 292: the mlvm redefineClassInBootstrap test crashes in ConstantPool::compare_entry_to sspitsyn parents: 7949 diff changeset	1208
edd76a5856f7 8005128: JSR 292: the mlvm redefineClassInBootstrap test crashes in ConstantPool::compare_entry_to sspitsyn parents: 7949 diff changeset	1209 } // end copy_cp_to_impl()
0 a61af66fc99e Initial load duke parents: diff changeset	1210
a61af66fc99e Initial load duke parents: diff changeset	1211
a61af66fc99e Initial load duke parents: diff changeset	1212 // Copy this constant pool's entry at from_i to the constant pool
a61af66fc99e Initial load duke parents: diff changeset	1213 // to_cp's entry at to_i.
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1214 void ConstantPool::copy_entry_to(constantPoolHandle from_cp, int from_i,
2011 dad31fc330cd 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute jrose parents: 1972 diff changeset	1215 constantPoolHandle to_cp, int to_i,
dad31fc330cd 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute jrose parents: 1972 diff changeset	1216 TRAPS) {
0 a61af66fc99e Initial load duke parents: diff changeset	1217
2011 dad31fc330cd 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute jrose parents: 1972 diff changeset	1218 int tag = from_cp->tag_at(from_i).value();
dad31fc330cd 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute jrose parents: 1972 diff changeset	1219 switch (tag) {
0 a61af66fc99e Initial load duke parents: diff changeset	1220 case JVM_CONSTANT_Class:
a61af66fc99e Initial load duke parents: diff changeset	1221 {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1222 Klass* k = from_cp->klass_at(from_i, CHECK);
0 a61af66fc99e Initial load duke parents: diff changeset	1223 to_cp->klass_at_put(to_i, k);
a61af66fc99e Initial load duke parents: diff changeset	1224 } break;
a61af66fc99e Initial load duke parents: diff changeset	1225
a61af66fc99e Initial load duke parents: diff changeset	1226 case JVM_CONSTANT_ClassIndex:
a61af66fc99e Initial load duke parents: diff changeset	1227 {
2011 dad31fc330cd 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute jrose parents: 1972 diff changeset	1228 jint ki = from_cp->klass_index_at(from_i);
0 a61af66fc99e Initial load duke parents: diff changeset	1229 to_cp->klass_index_at_put(to_i, ki);
a61af66fc99e Initial load duke parents: diff changeset	1230 } break;
a61af66fc99e Initial load duke parents: diff changeset	1231
a61af66fc99e Initial load duke parents: diff changeset	1232 case JVM_CONSTANT_Double:
a61af66fc99e Initial load duke parents: diff changeset	1233 {
2011 dad31fc330cd 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute jrose parents: 1972 diff changeset	1234 jdouble d = from_cp->double_at(from_i);
0 a61af66fc99e Initial load duke parents: diff changeset	1235 to_cp->double_at_put(to_i, d);
a61af66fc99e Initial load duke parents: diff changeset	1236 // double takes two constant pool entries so init second entry's tag
a61af66fc99e Initial load duke parents: diff changeset	1237 to_cp->tag_at_put(to_i + 1, JVM_CONSTANT_Invalid);
a61af66fc99e Initial load duke parents: diff changeset	1238 } break;
a61af66fc99e Initial load duke parents: diff changeset	1239
a61af66fc99e Initial load duke parents: diff changeset	1240 case JVM_CONSTANT_Fieldref:
a61af66fc99e Initial load duke parents: diff changeset	1241 {
2011 dad31fc330cd 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute jrose parents: 1972 diff changeset	1242 int class_index = from_cp->uncached_klass_ref_index_at(from_i);
dad31fc330cd 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute jrose parents: 1972 diff changeset	1243 int name_and_type_index = from_cp->uncached_name_and_type_ref_index_at(from_i);
0 a61af66fc99e Initial load duke parents: diff changeset	1244 to_cp->field_at_put(to_i, class_index, name_and_type_index);
a61af66fc99e Initial load duke parents: diff changeset	1245 } break;
a61af66fc99e Initial load duke parents: diff changeset	1246
a61af66fc99e Initial load duke parents: diff changeset	1247 case JVM_CONSTANT_Float:
a61af66fc99e Initial load duke parents: diff changeset	1248 {
2011 dad31fc330cd 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute jrose parents: 1972 diff changeset	1249 jfloat f = from_cp->float_at(from_i);
0 a61af66fc99e Initial load duke parents: diff changeset	1250 to_cp->float_at_put(to_i, f);
a61af66fc99e Initial load duke parents: diff changeset	1251 } break;
a61af66fc99e Initial load duke parents: diff changeset	1252
a61af66fc99e Initial load duke parents: diff changeset	1253 case JVM_CONSTANT_Integer:
a61af66fc99e Initial load duke parents: diff changeset	1254 {
2011 dad31fc330cd 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute jrose parents: 1972 diff changeset	1255 jint i = from_cp->int_at(from_i);
0 a61af66fc99e Initial load duke parents: diff changeset	1256 to_cp->int_at_put(to_i, i);
a61af66fc99e Initial load duke parents: diff changeset	1257 } break;
a61af66fc99e Initial load duke parents: diff changeset	1258
a61af66fc99e Initial load duke parents: diff changeset	1259 case JVM_CONSTANT_InterfaceMethodref:
a61af66fc99e Initial load duke parents: diff changeset	1260 {
2011 dad31fc330cd 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute jrose parents: 1972 diff changeset	1261 int class_index = from_cp->uncached_klass_ref_index_at(from_i);
dad31fc330cd 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute jrose parents: 1972 diff changeset	1262 int name_and_type_index = from_cp->uncached_name_and_type_ref_index_at(from_i);
0 a61af66fc99e Initial load duke parents: diff changeset	1263 to_cp->interface_method_at_put(to_i, class_index, name_and_type_index);
a61af66fc99e Initial load duke parents: diff changeset	1264 } break;
a61af66fc99e Initial load duke parents: diff changeset	1265
a61af66fc99e Initial load duke parents: diff changeset	1266 case JVM_CONSTANT_Long:
a61af66fc99e Initial load duke parents: diff changeset	1267 {
2011 dad31fc330cd 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute jrose parents: 1972 diff changeset	1268 jlong l = from_cp->long_at(from_i);
0 a61af66fc99e Initial load duke parents: diff changeset	1269 to_cp->long_at_put(to_i, l);
a61af66fc99e Initial load duke parents: diff changeset	1270 // long takes two constant pool entries so init second entry's tag
a61af66fc99e Initial load duke parents: diff changeset	1271 to_cp->tag_at_put(to_i + 1, JVM_CONSTANT_Invalid);
a61af66fc99e Initial load duke parents: diff changeset	1272 } break;
a61af66fc99e Initial load duke parents: diff changeset	1273
a61af66fc99e Initial load duke parents: diff changeset	1274 case JVM_CONSTANT_Methodref:
a61af66fc99e Initial load duke parents: diff changeset	1275 {
2011 dad31fc330cd 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute jrose parents: 1972 diff changeset	1276 int class_index = from_cp->uncached_klass_ref_index_at(from_i);
dad31fc330cd 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute jrose parents: 1972 diff changeset	1277 int name_and_type_index = from_cp->uncached_name_and_type_ref_index_at(from_i);
0 a61af66fc99e Initial load duke parents: diff changeset	1278 to_cp->method_at_put(to_i, class_index, name_and_type_index);
a61af66fc99e Initial load duke parents: diff changeset	1279 } break;
a61af66fc99e Initial load duke parents: diff changeset	1280
a61af66fc99e Initial load duke parents: diff changeset	1281 case JVM_CONSTANT_NameAndType:
a61af66fc99e Initial load duke parents: diff changeset	1282 {
2011 dad31fc330cd 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute jrose parents: 1972 diff changeset	1283 int name_ref_index = from_cp->name_ref_index_at(from_i);
dad31fc330cd 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute jrose parents: 1972 diff changeset	1284 int signature_ref_index = from_cp->signature_ref_index_at(from_i);
0 a61af66fc99e Initial load duke parents: diff changeset	1285 to_cp->name_and_type_at_put(to_i, name_ref_index, signature_ref_index);
a61af66fc99e Initial load duke parents: diff changeset	1286 } break;
a61af66fc99e Initial load duke parents: diff changeset	1287
a61af66fc99e Initial load duke parents: diff changeset	1288 case JVM_CONSTANT_StringIndex:
a61af66fc99e Initial load duke parents: diff changeset	1289 {
2011 dad31fc330cd 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute jrose parents: 1972 diff changeset	1290 jint si = from_cp->string_index_at(from_i);
0 a61af66fc99e Initial load duke parents: diff changeset	1291 to_cp->string_index_at_put(to_i, si);
a61af66fc99e Initial load duke parents: diff changeset	1292 } break;
a61af66fc99e Initial load duke parents: diff changeset	1293
a61af66fc99e Initial load duke parents: diff changeset	1294 case JVM_CONSTANT_UnresolvedClass:
a61af66fc99e Initial load duke parents: diff changeset	1295 {
2332 fbbeec6dad2d 6512830: Error: assert(tag_at(which).is_unresolved_klass(), "Corrupted constant pool") coleenp parents: 2177 diff changeset	1296 // Can be resolved after checking tag, so check the slot first.
fbbeec6dad2d 6512830: Error: assert(tag_at(which).is_unresolved_klass(), "Corrupted constant pool") coleenp parents: 2177 diff changeset	1297 CPSlot entry = from_cp->slot_at(from_i);
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1298 if (entry.is_resolved()) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1299 assert(entry.get_klass()->is_klass(), "must be");
2332 fbbeec6dad2d 6512830: Error: assert(tag_at(which).is_unresolved_klass(), "Corrupted constant pool") coleenp parents: 2177 diff changeset	1300 // Already resolved
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1301 to_cp->klass_at_put(to_i, entry.get_klass());
2332 fbbeec6dad2d 6512830: Error: assert(tag_at(which).is_unresolved_klass(), "Corrupted constant pool") coleenp parents: 2177 diff changeset	1302 } else {
fbbeec6dad2d 6512830: Error: assert(tag_at(which).is_unresolved_klass(), "Corrupted constant pool") coleenp parents: 2177 diff changeset	1303 to_cp->unresolved_klass_at_put(to_i, entry.get_symbol());
fbbeec6dad2d 6512830: Error: assert(tag_at(which).is_unresolved_klass(), "Corrupted constant pool") coleenp parents: 2177 diff changeset	1304 }
0 a61af66fc99e Initial load duke parents: diff changeset	1305 } break;
a61af66fc99e Initial load duke parents: diff changeset	1306
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1307 case JVM_CONSTANT_String:
0 a61af66fc99e Initial load duke parents: diff changeset	1308 {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1309 Symbol* s = from_cp->unresolved_string_at(from_i);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1310 to_cp->unresolved_string_at_put(to_i, s);
0 a61af66fc99e Initial load duke parents: diff changeset	1311 } break;
a61af66fc99e Initial load duke parents: diff changeset	1312
a61af66fc99e Initial load duke parents: diff changeset	1313 case JVM_CONSTANT_Utf8:
a61af66fc99e Initial load duke parents: diff changeset	1314 {
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	1315 Symbol* s = from_cp->symbol_at(from_i);
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1316 // Need to increase refcount, the old one will be thrown away and deferenced
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1317 s->increment_refcount();
0 a61af66fc99e Initial load duke parents: diff changeset	1318 to_cp->symbol_at_put(to_i, s);
a61af66fc99e Initial load duke parents: diff changeset	1319 } break;
a61af66fc99e Initial load duke parents: diff changeset	1320
1602 136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	1321 case JVM_CONSTANT_MethodType:
12845 b4a4fdc1f464 8025185: MethodHandleInError and MethodTypeInError not handled in ConstantPool::compare_entry_to and copy_entry_to coleenp parents: 12316 diff changeset	1322 case JVM_CONSTANT_MethodTypeInError:
1602 136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	1323 {
12845 b4a4fdc1f464 8025185: MethodHandleInError and MethodTypeInError not handled in ConstantPool::compare_entry_to and copy_entry_to coleenp parents: 12316 diff changeset	1324 jint k = from_cp->method_type_index_at_error_ok(from_i);
1602 136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	1325 to_cp->method_type_index_at_put(to_i, k);
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	1326 } break;
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	1327
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	1328 case JVM_CONSTANT_MethodHandle:
12845 b4a4fdc1f464 8025185: MethodHandleInError and MethodTypeInError not handled in ConstantPool::compare_entry_to and copy_entry_to coleenp parents: 12316 diff changeset	1329 case JVM_CONSTANT_MethodHandleInError:
1602 136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	1330 {
12845 b4a4fdc1f464 8025185: MethodHandleInError and MethodTypeInError not handled in ConstantPool::compare_entry_to and copy_entry_to coleenp parents: 12316 diff changeset	1331 int k1 = from_cp->method_handle_ref_kind_at_error_ok(from_i);
b4a4fdc1f464 8025185: MethodHandleInError and MethodTypeInError not handled in ConstantPool::compare_entry_to and copy_entry_to coleenp parents: 12316 diff changeset	1332 int k2 = from_cp->method_handle_index_at_error_ok(from_i);
1602 136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	1333 to_cp->method_handle_index_at_put(to_i, k1, k2);
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	1334 } break;
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	1335
1660 083fde3b838e 6964498: JSR 292 invokedynamic sites need local bootstrap methods jrose parents: 1602 diff changeset	1336 case JVM_CONSTANT_InvokeDynamic:
083fde3b838e 6964498: JSR 292 invokedynamic sites need local bootstrap methods jrose parents: 1602 diff changeset	1337 {
2011 dad31fc330cd 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute jrose parents: 1972 diff changeset	1338 int k1 = from_cp->invoke_dynamic_bootstrap_specifier_index(from_i);
dad31fc330cd 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute jrose parents: 1972 diff changeset	1339 int k2 = from_cp->invoke_dynamic_name_and_type_ref_index_at(from_i);
dad31fc330cd 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute jrose parents: 1972 diff changeset	1340 k1 += operand_array_length(to_cp->operands()); // to_cp might already have operands
dad31fc330cd 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute jrose parents: 1972 diff changeset	1341 to_cp->invoke_dynamic_at_put(to_i, k1, k2);
1660 083fde3b838e 6964498: JSR 292 invokedynamic sites need local bootstrap methods jrose parents: 1602 diff changeset	1342 } break;
083fde3b838e 6964498: JSR 292 invokedynamic sites need local bootstrap methods jrose parents: 1602 diff changeset	1343
0 a61af66fc99e Initial load duke parents: diff changeset	1344 // Invalid is used as the tag for the second constant pool entry
a61af66fc99e Initial load duke parents: diff changeset	1345 // occupied by JVM_CONSTANT_Double or JVM_CONSTANT_Long. It should
a61af66fc99e Initial load duke parents: diff changeset	1346 // not be seen by itself.
a61af66fc99e Initial load duke parents: diff changeset	1347 case JVM_CONSTANT_Invalid: // fall through
a61af66fc99e Initial load duke parents: diff changeset	1348
a61af66fc99e Initial load duke parents: diff changeset	1349 default:
a61af66fc99e Initial load duke parents: diff changeset	1350 {
a61af66fc99e Initial load duke parents: diff changeset	1351 ShouldNotReachHere();
a61af66fc99e Initial load duke parents: diff changeset	1352 } break;
a61af66fc99e Initial load duke parents: diff changeset	1353 }
a61af66fc99e Initial load duke parents: diff changeset	1354 } // end copy_entry_to()
a61af66fc99e Initial load duke parents: diff changeset	1355
a61af66fc99e Initial load duke parents: diff changeset	1356
a61af66fc99e Initial load duke parents: diff changeset	1357 // Search constant pool search_cp for an entry that matches this
a61af66fc99e Initial load duke parents: diff changeset	1358 // constant pool's entry at pattern_i. Returns the index of a
a61af66fc99e Initial load duke parents: diff changeset	1359 // matching entry or zero (0) if there is no matching entry.
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1360 int ConstantPool::find_matching_entry(int pattern_i,
0 a61af66fc99e Initial load duke parents: diff changeset	1361 constantPoolHandle search_cp, TRAPS) {
a61af66fc99e Initial load duke parents: diff changeset	1362
a61af66fc99e Initial load duke parents: diff changeset	1363 // index zero (0) is not used
a61af66fc99e Initial load duke parents: diff changeset	1364 for (int i = 1; i < search_cp->length(); i++) {
a61af66fc99e Initial load duke parents: diff changeset	1365 bool found = compare_entry_to(pattern_i, search_cp, i, CHECK_0);
a61af66fc99e Initial load duke parents: diff changeset	1366 if (found) {
a61af66fc99e Initial load duke parents: diff changeset	1367 return i;
a61af66fc99e Initial load duke parents: diff changeset	1368 }
a61af66fc99e Initial load duke parents: diff changeset	1369 }
a61af66fc99e Initial load duke parents: diff changeset	1370
a61af66fc99e Initial load duke parents: diff changeset	1371 return 0; // entry not found; return unused index zero (0)
a61af66fc99e Initial load duke parents: diff changeset	1372 } // end find_matching_entry()
a61af66fc99e Initial load duke parents: diff changeset	1373
a61af66fc99e Initial load duke parents: diff changeset	1374
10151 15a99ca4ee34 8007037: JSR 292: the VM_RedefineClasses::append_entry() should do cross-checks with indy operands sspitsyn parents: 9060 diff changeset	1375 // Compare this constant pool's bootstrap specifier at idx1 to the constant pool
15a99ca4ee34 8007037: JSR 292: the VM_RedefineClasses::append_entry() should do cross-checks with indy operands sspitsyn parents: 9060 diff changeset	1376 // cp2's bootstrap specifier at idx2.
15a99ca4ee34 8007037: JSR 292: the VM_RedefineClasses::append_entry() should do cross-checks with indy operands sspitsyn parents: 9060 diff changeset	1377 bool ConstantPool::compare_operand_to(int idx1, constantPoolHandle cp2, int idx2, TRAPS) {
15a99ca4ee34 8007037: JSR 292: the VM_RedefineClasses::append_entry() should do cross-checks with indy operands sspitsyn parents: 9060 diff changeset	1378 int k1 = operand_bootstrap_method_ref_index_at(idx1);
15a99ca4ee34 8007037: JSR 292: the VM_RedefineClasses::append_entry() should do cross-checks with indy operands sspitsyn parents: 9060 diff changeset	1379 int k2 = cp2->operand_bootstrap_method_ref_index_at(idx2);
15a99ca4ee34 8007037: JSR 292: the VM_RedefineClasses::append_entry() should do cross-checks with indy operands sspitsyn parents: 9060 diff changeset	1380 bool match = compare_entry_to(k1, cp2, k2, CHECK_false);
15a99ca4ee34 8007037: JSR 292: the VM_RedefineClasses::append_entry() should do cross-checks with indy operands sspitsyn parents: 9060 diff changeset	1381
15a99ca4ee34 8007037: JSR 292: the VM_RedefineClasses::append_entry() should do cross-checks with indy operands sspitsyn parents: 9060 diff changeset	1382 if (!match) {
15a99ca4ee34 8007037: JSR 292: the VM_RedefineClasses::append_entry() should do cross-checks with indy operands sspitsyn parents: 9060 diff changeset	1383 return false;
15a99ca4ee34 8007037: JSR 292: the VM_RedefineClasses::append_entry() should do cross-checks with indy operands sspitsyn parents: 9060 diff changeset	1384 }
15a99ca4ee34 8007037: JSR 292: the VM_RedefineClasses::append_entry() should do cross-checks with indy operands sspitsyn parents: 9060 diff changeset	1385 int argc = operand_argument_count_at(idx1);
15a99ca4ee34 8007037: JSR 292: the VM_RedefineClasses::append_entry() should do cross-checks with indy operands sspitsyn parents: 9060 diff changeset	1386 if (argc == cp2->operand_argument_count_at(idx2)) {
15a99ca4ee34 8007037: JSR 292: the VM_RedefineClasses::append_entry() should do cross-checks with indy operands sspitsyn parents: 9060 diff changeset	1387 for (int j = 0; j < argc; j++) {
15a99ca4ee34 8007037: JSR 292: the VM_RedefineClasses::append_entry() should do cross-checks with indy operands sspitsyn parents: 9060 diff changeset	1388 k1 = operand_argument_index_at(idx1, j);
15a99ca4ee34 8007037: JSR 292: the VM_RedefineClasses::append_entry() should do cross-checks with indy operands sspitsyn parents: 9060 diff changeset	1389 k2 = cp2->operand_argument_index_at(idx2, j);
15a99ca4ee34 8007037: JSR 292: the VM_RedefineClasses::append_entry() should do cross-checks with indy operands sspitsyn parents: 9060 diff changeset	1390 match = compare_entry_to(k1, cp2, k2, CHECK_false);
15a99ca4ee34 8007037: JSR 292: the VM_RedefineClasses::append_entry() should do cross-checks with indy operands sspitsyn parents: 9060 diff changeset	1391 if (!match) {
15a99ca4ee34 8007037: JSR 292: the VM_RedefineClasses::append_entry() should do cross-checks with indy operands sspitsyn parents: 9060 diff changeset	1392 return false;
15a99ca4ee34 8007037: JSR 292: the VM_RedefineClasses::append_entry() should do cross-checks with indy operands sspitsyn parents: 9060 diff changeset	1393 }
15a99ca4ee34 8007037: JSR 292: the VM_RedefineClasses::append_entry() should do cross-checks with indy operands sspitsyn parents: 9060 diff changeset	1394 }
15a99ca4ee34 8007037: JSR 292: the VM_RedefineClasses::append_entry() should do cross-checks with indy operands sspitsyn parents: 9060 diff changeset	1395 return true; // got through loop; all elements equal
15a99ca4ee34 8007037: JSR 292: the VM_RedefineClasses::append_entry() should do cross-checks with indy operands sspitsyn parents: 9060 diff changeset	1396 }
15a99ca4ee34 8007037: JSR 292: the VM_RedefineClasses::append_entry() should do cross-checks with indy operands sspitsyn parents: 9060 diff changeset	1397 return false;
15a99ca4ee34 8007037: JSR 292: the VM_RedefineClasses::append_entry() should do cross-checks with indy operands sspitsyn parents: 9060 diff changeset	1398 } // end compare_operand_to()
15a99ca4ee34 8007037: JSR 292: the VM_RedefineClasses::append_entry() should do cross-checks with indy operands sspitsyn parents: 9060 diff changeset	1399
15a99ca4ee34 8007037: JSR 292: the VM_RedefineClasses::append_entry() should do cross-checks with indy operands sspitsyn parents: 9060 diff changeset	1400 // Search constant pool search_cp for a bootstrap specifier that matches
15a99ca4ee34 8007037: JSR 292: the VM_RedefineClasses::append_entry() should do cross-checks with indy operands sspitsyn parents: 9060 diff changeset	1401 // this constant pool's bootstrap specifier at pattern_i index.
15a99ca4ee34 8007037: JSR 292: the VM_RedefineClasses::append_entry() should do cross-checks with indy operands sspitsyn parents: 9060 diff changeset	1402 // Return the index of a matching bootstrap specifier or (-1) if there is no match.
15a99ca4ee34 8007037: JSR 292: the VM_RedefineClasses::append_entry() should do cross-checks with indy operands sspitsyn parents: 9060 diff changeset	1403 int ConstantPool::find_matching_operand(int pattern_i,
15a99ca4ee34 8007037: JSR 292: the VM_RedefineClasses::append_entry() should do cross-checks with indy operands sspitsyn parents: 9060 diff changeset	1404 constantPoolHandle search_cp, int search_len, TRAPS) {
15a99ca4ee34 8007037: JSR 292: the VM_RedefineClasses::append_entry() should do cross-checks with indy operands sspitsyn parents: 9060 diff changeset	1405 for (int i = 0; i < search_len; i++) {
15a99ca4ee34 8007037: JSR 292: the VM_RedefineClasses::append_entry() should do cross-checks with indy operands sspitsyn parents: 9060 diff changeset	1406 bool found = compare_operand_to(pattern_i, search_cp, i, CHECK_(-1));
15a99ca4ee34 8007037: JSR 292: the VM_RedefineClasses::append_entry() should do cross-checks with indy operands sspitsyn parents: 9060 diff changeset	1407 if (found) {
15a99ca4ee34 8007037: JSR 292: the VM_RedefineClasses::append_entry() should do cross-checks with indy operands sspitsyn parents: 9060 diff changeset	1408 return i;
15a99ca4ee34 8007037: JSR 292: the VM_RedefineClasses::append_entry() should do cross-checks with indy operands sspitsyn parents: 9060 diff changeset	1409 }
15a99ca4ee34 8007037: JSR 292: the VM_RedefineClasses::append_entry() should do cross-checks with indy operands sspitsyn parents: 9060 diff changeset	1410 }
15a99ca4ee34 8007037: JSR 292: the VM_RedefineClasses::append_entry() should do cross-checks with indy operands sspitsyn parents: 9060 diff changeset	1411 return -1; // bootstrap specifier not found; return unused index (-1)
15a99ca4ee34 8007037: JSR 292: the VM_RedefineClasses::append_entry() should do cross-checks with indy operands sspitsyn parents: 9060 diff changeset	1412 } // end find_matching_operand()
15a99ca4ee34 8007037: JSR 292: the VM_RedefineClasses::append_entry() should do cross-checks with indy operands sspitsyn parents: 9060 diff changeset	1413
15a99ca4ee34 8007037: JSR 292: the VM_RedefineClasses::append_entry() should do cross-checks with indy operands sspitsyn parents: 9060 diff changeset	1414
0 a61af66fc99e Initial load duke parents: diff changeset	1415 #ifndef PRODUCT
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 const char* ConstantPool::printable_name_at(int which) {
0 a61af66fc99e Initial load duke parents: diff changeset	1418
a61af66fc99e Initial load duke parents: diff changeset	1419 constantTag tag = tag_at(which);
a61af66fc99e Initial load duke parents: diff changeset	1420
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1421 if (tag.is_string()) {
0 a61af66fc99e Initial load duke parents: diff changeset	1422 return string_at_noresolve(which);
a61af66fc99e Initial load duke parents: diff changeset	1423 } else if (tag.is_klass() \|\| tag.is_unresolved_klass()) {
a61af66fc99e Initial load duke parents: diff changeset	1424 return klass_name_at(which)->as_C_string();
a61af66fc99e Initial load duke parents: diff changeset	1425 } else if (tag.is_symbol()) {
a61af66fc99e Initial load duke parents: diff changeset	1426 return symbol_at(which)->as_C_string();
a61af66fc99e Initial load duke parents: diff changeset	1427 }
a61af66fc99e Initial load duke parents: diff changeset	1428 return "";
a61af66fc99e Initial load duke parents: diff changeset	1429 }
a61af66fc99e Initial load duke parents: diff changeset	1430
a61af66fc99e Initial load duke parents: diff changeset	1431 #endif // PRODUCT
a61af66fc99e Initial load duke parents: diff changeset	1432
a61af66fc99e Initial load duke parents: diff changeset	1433
a61af66fc99e Initial load duke parents: diff changeset	1434 // JVMTI GetConstantPool support
a61af66fc99e Initial load duke parents: diff changeset	1435
9060 cc32ccaaf47f 8003310: Enable -Wunused-function when compiling with gcc mikael parents: 8782 diff changeset	1436 // For debugging of constant pool
cc32ccaaf47f 8003310: Enable -Wunused-function when compiling with gcc mikael parents: 8782 diff changeset	1437 const bool debug_cpool = false;
0 a61af66fc99e Initial load duke parents: diff changeset	1438
9060 cc32ccaaf47f 8003310: Enable -Wunused-function when compiling with gcc mikael parents: 8782 diff changeset	1439 #define DBG(code) do { if (debug_cpool) { (code); } } while(0)
0 a61af66fc99e Initial load duke parents: diff changeset	1440
a61af66fc99e Initial load duke parents: diff changeset	1441 static void print_cpool_bytes(jint cnt, u1 *bytes) {
9060 cc32ccaaf47f 8003310: Enable -Wunused-function when compiling with gcc mikael parents: 8782 diff changeset	1442 const char* WARN_MSG = "Must not be such entry!";
0 a61af66fc99e Initial load duke parents: diff changeset	1443 jint size = 0;
a61af66fc99e Initial load duke parents: diff changeset	1444 u2 idx1, idx2;
a61af66fc99e Initial load duke parents: diff changeset	1445
a61af66fc99e Initial load duke parents: diff changeset	1446 for (jint idx = 1; idx < cnt; idx++) {
a61af66fc99e Initial load duke parents: diff changeset	1447 jint ent_size = 0;
a61af66fc99e Initial load duke parents: diff changeset	1448 u1 tag = *bytes++;
a61af66fc99e Initial load duke parents: diff changeset	1449 size++; // count tag
a61af66fc99e Initial load duke parents: diff changeset	1450
a61af66fc99e Initial load duke parents: diff changeset	1451 printf("const #%03d, tag: %02d ", idx, tag);
a61af66fc99e Initial load duke parents: diff changeset	1452 switch(tag) {
a61af66fc99e Initial load duke parents: diff changeset	1453 case JVM_CONSTANT_Invalid: {
a61af66fc99e Initial load duke parents: diff changeset	1454 printf("Invalid");
a61af66fc99e Initial load duke parents: diff changeset	1455 break;
a61af66fc99e Initial load duke parents: diff changeset	1456 }
a61af66fc99e Initial load duke parents: diff changeset	1457 case JVM_CONSTANT_Unicode: {
a61af66fc99e Initial load duke parents: diff changeset	1458 printf("Unicode %s", WARN_MSG);
a61af66fc99e Initial load duke parents: diff changeset	1459 break;
a61af66fc99e Initial load duke parents: diff changeset	1460 }
a61af66fc99e Initial load duke parents: diff changeset	1461 case JVM_CONSTANT_Utf8: {
a61af66fc99e Initial load duke parents: diff changeset	1462 u2 len = Bytes::get_Java_u2(bytes);
a61af66fc99e Initial load duke parents: diff changeset	1463 char str[128];
a61af66fc99e Initial load duke parents: diff changeset	1464 if (len > 127) {
a61af66fc99e Initial load duke parents: diff changeset	1465 len = 127;
a61af66fc99e Initial load duke parents: diff changeset	1466 }
a61af66fc99e Initial load duke parents: diff changeset	1467 strncpy(str, (char *) (bytes+2), len);
a61af66fc99e Initial load duke parents: diff changeset	1468 str[len] = '\0';
a61af66fc99e Initial load duke parents: diff changeset	1469 printf("Utf8 \"%s\"", str);
a61af66fc99e Initial load duke parents: diff changeset	1470 ent_size = 2 + len;
a61af66fc99e Initial load duke parents: diff changeset	1471 break;
a61af66fc99e Initial load duke parents: diff changeset	1472 }
a61af66fc99e Initial load duke parents: diff changeset	1473 case JVM_CONSTANT_Integer: {
a61af66fc99e Initial load duke parents: diff changeset	1474 u4 val = Bytes::get_Java_u4(bytes);
a61af66fc99e Initial load duke parents: diff changeset	1475 printf("int %d", (int ) &val);
a61af66fc99e Initial load duke parents: diff changeset	1476 ent_size = 4;
a61af66fc99e Initial load duke parents: diff changeset	1477 break;
a61af66fc99e Initial load duke parents: diff changeset	1478 }
a61af66fc99e Initial load duke parents: diff changeset	1479 case JVM_CONSTANT_Float: {
a61af66fc99e Initial load duke parents: diff changeset	1480 u4 val = Bytes::get_Java_u4(bytes);
a61af66fc99e Initial load duke parents: diff changeset	1481 printf("float %5.3ff", (float ) &val);
a61af66fc99e Initial load duke parents: diff changeset	1482 ent_size = 4;
a61af66fc99e Initial load duke parents: diff changeset	1483 break;
a61af66fc99e Initial load duke parents: diff changeset	1484 }
a61af66fc99e Initial load duke parents: diff changeset	1485 case JVM_CONSTANT_Long: {
a61af66fc99e Initial load duke parents: diff changeset	1486 u8 val = Bytes::get_Java_u8(bytes);
3960 f08d439fab8c 7089790: integrate bsd-port changes never parents: 3461 diff changeset	1487 printf("long "INT64_FORMAT, (int64_t) (jlong ) &val);
0 a61af66fc99e Initial load duke parents: diff changeset	1488 ent_size = 8;
a61af66fc99e Initial load duke parents: diff changeset	1489 idx++; // Long takes two cpool slots
a61af66fc99e Initial load duke parents: diff changeset	1490 break;
a61af66fc99e Initial load duke parents: diff changeset	1491 }
a61af66fc99e Initial load duke parents: diff changeset	1492 case JVM_CONSTANT_Double: {
a61af66fc99e Initial load duke parents: diff changeset	1493 u8 val = Bytes::get_Java_u8(bytes);
a61af66fc99e Initial load duke parents: diff changeset	1494 printf("double %5.3fd", (jdouble )&val);
a61af66fc99e Initial load duke parents: diff changeset	1495 ent_size = 8;
a61af66fc99e Initial load duke parents: diff changeset	1496 idx++; // Double takes two cpool slots
a61af66fc99e Initial load duke parents: diff changeset	1497 break;
a61af66fc99e Initial load duke parents: diff changeset	1498 }
a61af66fc99e Initial load duke parents: diff changeset	1499 case JVM_CONSTANT_Class: {
a61af66fc99e Initial load duke parents: diff changeset	1500 idx1 = Bytes::get_Java_u2(bytes);
a61af66fc99e Initial load duke parents: diff changeset	1501 printf("class #%03d", idx1);
a61af66fc99e Initial load duke parents: diff changeset	1502 ent_size = 2;
a61af66fc99e Initial load duke parents: diff changeset	1503 break;
a61af66fc99e Initial load duke parents: diff changeset	1504 }
a61af66fc99e Initial load duke parents: diff changeset	1505 case JVM_CONSTANT_String: {
a61af66fc99e Initial load duke parents: diff changeset	1506 idx1 = Bytes::get_Java_u2(bytes);
a61af66fc99e Initial load duke parents: diff changeset	1507 printf("String #%03d", idx1);
a61af66fc99e Initial load duke parents: diff changeset	1508 ent_size = 2;
a61af66fc99e Initial load duke parents: diff changeset	1509 break;
a61af66fc99e Initial load duke parents: diff changeset	1510 }
a61af66fc99e Initial load duke parents: diff changeset	1511 case JVM_CONSTANT_Fieldref: {
a61af66fc99e Initial load duke parents: diff changeset	1512 idx1 = Bytes::get_Java_u2(bytes);
a61af66fc99e Initial load duke parents: diff changeset	1513 idx2 = Bytes::get_Java_u2(bytes+2);
a61af66fc99e Initial load duke parents: diff changeset	1514 printf("Field #%03d, #%03d", (int) idx1, (int) idx2);
a61af66fc99e Initial load duke parents: diff changeset	1515 ent_size = 4;
a61af66fc99e Initial load duke parents: diff changeset	1516 break;
a61af66fc99e Initial load duke parents: diff changeset	1517 }
a61af66fc99e Initial load duke parents: diff changeset	1518 case JVM_CONSTANT_Methodref: {
a61af66fc99e Initial load duke parents: diff changeset	1519 idx1 = Bytes::get_Java_u2(bytes);
a61af66fc99e Initial load duke parents: diff changeset	1520 idx2 = Bytes::get_Java_u2(bytes+2);
a61af66fc99e Initial load duke parents: diff changeset	1521 printf("Method #%03d, #%03d", idx1, idx2);
a61af66fc99e Initial load duke parents: diff changeset	1522 ent_size = 4;
a61af66fc99e Initial load duke parents: diff changeset	1523 break;
a61af66fc99e Initial load duke parents: diff changeset	1524 }
a61af66fc99e Initial load duke parents: diff changeset	1525 case JVM_CONSTANT_InterfaceMethodref: {
a61af66fc99e Initial load duke parents: diff changeset	1526 idx1 = Bytes::get_Java_u2(bytes);
a61af66fc99e Initial load duke parents: diff changeset	1527 idx2 = Bytes::get_Java_u2(bytes+2);
a61af66fc99e Initial load duke parents: diff changeset	1528 printf("InterfMethod #%03d, #%03d", idx1, idx2);
a61af66fc99e Initial load duke parents: diff changeset	1529 ent_size = 4;
a61af66fc99e Initial load duke parents: diff changeset	1530 break;
a61af66fc99e Initial load duke parents: diff changeset	1531 }
a61af66fc99e Initial load duke parents: diff changeset	1532 case JVM_CONSTANT_NameAndType: {
a61af66fc99e Initial load duke parents: diff changeset	1533 idx1 = Bytes::get_Java_u2(bytes);
a61af66fc99e Initial load duke parents: diff changeset	1534 idx2 = Bytes::get_Java_u2(bytes+2);
a61af66fc99e Initial load duke parents: diff changeset	1535 printf("NameAndType #%03d, #%03d", idx1, idx2);
a61af66fc99e Initial load duke parents: diff changeset	1536 ent_size = 4;
a61af66fc99e Initial load duke parents: diff changeset	1537 break;
a61af66fc99e Initial load duke parents: diff changeset	1538 }
a61af66fc99e Initial load duke parents: diff changeset	1539 case JVM_CONSTANT_ClassIndex: {
a61af66fc99e Initial load duke parents: diff changeset	1540 printf("ClassIndex %s", WARN_MSG);
a61af66fc99e Initial load duke parents: diff changeset	1541 break;
a61af66fc99e Initial load duke parents: diff changeset	1542 }
a61af66fc99e Initial load duke parents: diff changeset	1543 case JVM_CONSTANT_UnresolvedClass: {
a61af66fc99e Initial load duke parents: diff changeset	1544 printf("UnresolvedClass: %s", WARN_MSG);
a61af66fc99e Initial load duke parents: diff changeset	1545 break;
a61af66fc99e Initial load duke parents: diff changeset	1546 }
a61af66fc99e Initial load duke parents: diff changeset	1547 case JVM_CONSTANT_UnresolvedClassInError: {
a61af66fc99e Initial load duke parents: diff changeset	1548 printf("UnresolvedClassInErr: %s", WARN_MSG);
a61af66fc99e Initial load duke parents: diff changeset	1549 break;
a61af66fc99e Initial load duke parents: diff changeset	1550 }
a61af66fc99e Initial load duke parents: diff changeset	1551 case JVM_CONSTANT_StringIndex: {
a61af66fc99e Initial load duke parents: diff changeset	1552 printf("StringIndex: %s", WARN_MSG);
a61af66fc99e Initial load duke parents: diff changeset	1553 break;
a61af66fc99e Initial load duke parents: diff changeset	1554 }
a61af66fc99e Initial load duke parents: diff changeset	1555 }
a61af66fc99e Initial load duke parents: diff changeset	1556 printf(";\n");
a61af66fc99e Initial load duke parents: diff changeset	1557 bytes += ent_size;
a61af66fc99e Initial load duke parents: diff changeset	1558 size += ent_size;
a61af66fc99e Initial load duke parents: diff changeset	1559 }
a61af66fc99e Initial load duke parents: diff changeset	1560 printf("Cpool size: %d\n", size);
a61af66fc99e Initial load duke parents: diff changeset	1561 fflush(0);
a61af66fc99e Initial load duke parents: diff changeset	1562 return;
a61af66fc99e Initial load duke parents: diff changeset	1563 } /* end print_cpool_bytes */
a61af66fc99e Initial load duke parents: diff changeset	1564
a61af66fc99e Initial load duke parents: diff changeset	1565
a61af66fc99e Initial load duke parents: diff changeset	1566 // Returns size of constant pool entry.
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1567 jint ConstantPool::cpool_entry_size(jint idx) {
0 a61af66fc99e Initial load duke parents: diff changeset	1568 switch(tag_at(idx).value()) {
a61af66fc99e Initial load duke parents: diff changeset	1569 case JVM_CONSTANT_Invalid:
a61af66fc99e Initial load duke parents: diff changeset	1570 case JVM_CONSTANT_Unicode:
a61af66fc99e Initial load duke parents: diff changeset	1571 return 1;
a61af66fc99e Initial load duke parents: diff changeset	1572
a61af66fc99e Initial load duke parents: diff changeset	1573 case JVM_CONSTANT_Utf8:
a61af66fc99e Initial load duke parents: diff changeset	1574 return 3 + symbol_at(idx)->utf8_length();
a61af66fc99e Initial load duke parents: diff changeset	1575
a61af66fc99e Initial load duke parents: diff changeset	1576 case JVM_CONSTANT_Class:
a61af66fc99e Initial load duke parents: diff changeset	1577 case JVM_CONSTANT_String:
a61af66fc99e Initial load duke parents: diff changeset	1578 case JVM_CONSTANT_ClassIndex:
a61af66fc99e Initial load duke parents: diff changeset	1579 case JVM_CONSTANT_UnresolvedClass:
a61af66fc99e Initial load duke parents: diff changeset	1580 case JVM_CONSTANT_UnresolvedClassInError:
a61af66fc99e Initial load duke parents: diff changeset	1581 case JVM_CONSTANT_StringIndex:
1602 136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	1582 case JVM_CONSTANT_MethodType:
12292 084b21cd0228 8025088: Missing cases for JVM_CONSTANT_MethodHandleInError cause crash if debugger steps into error-tagged method handle iklam parents: 12288 diff changeset	1583 case JVM_CONSTANT_MethodTypeInError:
0 a61af66fc99e Initial load duke parents: diff changeset	1584 return 3;
a61af66fc99e Initial load duke parents: diff changeset	1585
1602 136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	1586 case JVM_CONSTANT_MethodHandle:
12292 084b21cd0228 8025088: Missing cases for JVM_CONSTANT_MethodHandleInError cause crash if debugger steps into error-tagged method handle iklam parents: 12288 diff changeset	1587 case JVM_CONSTANT_MethodHandleInError:
1602 136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	1588 return 4; //tag, ref_kind, ref_index
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	1589
0 a61af66fc99e Initial load duke parents: diff changeset	1590 case JVM_CONSTANT_Integer:
a61af66fc99e Initial load duke parents: diff changeset	1591 case JVM_CONSTANT_Float:
a61af66fc99e Initial load duke parents: diff changeset	1592 case JVM_CONSTANT_Fieldref:
a61af66fc99e Initial load duke parents: diff changeset	1593 case JVM_CONSTANT_Methodref:
a61af66fc99e Initial load duke parents: diff changeset	1594 case JVM_CONSTANT_InterfaceMethodref:
a61af66fc99e Initial load duke parents: diff changeset	1595 case JVM_CONSTANT_NameAndType:
1913 3b2dea75431e 6984311: JSR 292 needs optional bootstrap method parameters jrose parents: 1910 diff changeset	1596 return 5;
3b2dea75431e 6984311: JSR 292 needs optional bootstrap method parameters jrose parents: 1910 diff changeset	1597
1660 083fde3b838e 6964498: JSR 292 invokedynamic sites need local bootstrap methods jrose parents: 1602 diff changeset	1598 case JVM_CONSTANT_InvokeDynamic:
2011 dad31fc330cd 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute jrose parents: 1972 diff changeset	1599 // u1 tag, u2 bsm, u2 nt
dad31fc330cd 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute jrose parents: 1972 diff changeset	1600 return 5;
0 a61af66fc99e Initial load duke parents: diff changeset	1601
a61af66fc99e Initial load duke parents: diff changeset	1602 case JVM_CONSTANT_Long:
a61af66fc99e Initial load duke parents: diff changeset	1603 case JVM_CONSTANT_Double:
a61af66fc99e Initial load duke parents: diff changeset	1604 return 9;
a61af66fc99e Initial load duke parents: diff changeset	1605 }
a61af66fc99e Initial load duke parents: diff changeset	1606 assert(false, "cpool_entry_size: Invalid constant pool entry tag");
a61af66fc99e Initial load duke parents: diff changeset	1607 return 1;
a61af66fc99e Initial load duke parents: diff changeset	1608 } /* end cpool_entry_size */
a61af66fc99e Initial load duke parents: diff changeset	1609
a61af66fc99e Initial load duke parents: diff changeset	1610
a61af66fc99e Initial load duke parents: diff changeset	1611 // SymbolHashMap is used to find a constant pool index from a string.
a61af66fc99e Initial load duke parents: diff changeset	1612 // This function fills in SymbolHashMaps, one for utf8s and one for
a61af66fc99e Initial load duke parents: diff changeset	1613 // class names, returns size of the cpool raw bytes.
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1614 jint ConstantPool::hash_entries_to(SymbolHashMap *symmap,
0 a61af66fc99e Initial load duke parents: diff changeset	1615 SymbolHashMap *classmap) {
a61af66fc99e Initial load duke parents: diff changeset	1616 jint size = 0;
a61af66fc99e Initial load duke parents: diff changeset	1617
a61af66fc99e Initial load duke parents: diff changeset	1618 for (u2 idx = 1; idx < length(); idx++) {
a61af66fc99e Initial load duke parents: diff changeset	1619 u2 tag = tag_at(idx).value();
a61af66fc99e Initial load duke parents: diff changeset	1620 size += cpool_entry_size(idx);
a61af66fc99e Initial load duke parents: diff changeset	1621
a61af66fc99e Initial load duke parents: diff changeset	1622 switch(tag) {
a61af66fc99e Initial load duke parents: diff changeset	1623 case JVM_CONSTANT_Utf8: {
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	1624 Symbol* sym = symbol_at(idx);
0 a61af66fc99e Initial load duke parents: diff changeset	1625 symmap->add_entry(sym, idx);
a61af66fc99e Initial load duke parents: diff changeset	1626 DBG(printf("adding symbol entry %s = %d\n", sym->as_utf8(), idx));
a61af66fc99e Initial load duke parents: diff changeset	1627 break;
a61af66fc99e Initial load duke parents: diff changeset	1628 }
a61af66fc99e Initial load duke parents: diff changeset	1629 case JVM_CONSTANT_Class:
a61af66fc99e Initial load duke parents: diff changeset	1630 case JVM_CONSTANT_UnresolvedClass:
a61af66fc99e Initial load duke parents: diff changeset	1631 case JVM_CONSTANT_UnresolvedClassInError: {
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	1632 Symbol* sym = klass_name_at(idx);
0 a61af66fc99e Initial load duke parents: diff changeset	1633 classmap->add_entry(sym, idx);
a61af66fc99e Initial load duke parents: diff changeset	1634 DBG(printf("adding class entry %s = %d\n", sym->as_utf8(), idx));
a61af66fc99e Initial load duke parents: diff changeset	1635 break;
a61af66fc99e Initial load duke parents: diff changeset	1636 }
a61af66fc99e Initial load duke parents: diff changeset	1637 case JVM_CONSTANT_Long:
a61af66fc99e Initial load duke parents: diff changeset	1638 case JVM_CONSTANT_Double: {
a61af66fc99e Initial load duke parents: diff changeset	1639 idx++; // Both Long and Double take two cpool slots
a61af66fc99e Initial load duke parents: diff changeset	1640 break;
a61af66fc99e Initial load duke parents: diff changeset	1641 }
a61af66fc99e Initial load duke parents: diff changeset	1642 }
a61af66fc99e Initial load duke parents: diff changeset	1643 }
a61af66fc99e Initial load duke parents: diff changeset	1644 return size;
a61af66fc99e Initial load duke parents: diff changeset	1645 } /* end hash_utf8_entries_to */
a61af66fc99e Initial load duke parents: diff changeset	1646
a61af66fc99e Initial load duke parents: diff changeset	1647
a61af66fc99e Initial load duke parents: diff changeset	1648 // Copy cpool bytes.
a61af66fc99e Initial load duke parents: diff changeset	1649 // Returns:
a61af66fc99e Initial load duke parents: diff changeset	1650 // 0, in case of OutOfMemoryError
a61af66fc99e Initial load duke parents: diff changeset	1651 // -1, in case of internal error
a61af66fc99e Initial load duke parents: diff changeset	1652 // > 0, count of the raw cpool bytes that have been copied
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1653 int ConstantPool::copy_cpool_bytes(int cpool_size,
0 a61af66fc99e Initial load duke parents: diff changeset	1654 SymbolHashMap* tbl,
a61af66fc99e Initial load duke parents: diff changeset	1655 unsigned char *bytes) {
a61af66fc99e Initial load duke parents: diff changeset	1656 u2 idx1, idx2;
a61af66fc99e Initial load duke parents: diff changeset	1657 jint size = 0;
a61af66fc99e Initial load duke parents: diff changeset	1658 jint cnt = length();
a61af66fc99e Initial load duke parents: diff changeset	1659 unsigned char *start_bytes = bytes;
a61af66fc99e Initial load duke parents: diff changeset	1660
a61af66fc99e Initial load duke parents: diff changeset	1661 for (jint idx = 1; idx < cnt; idx++) {
a61af66fc99e Initial load duke parents: diff changeset	1662 u1 tag = tag_at(idx).value();
a61af66fc99e Initial load duke parents: diff changeset	1663 jint ent_size = cpool_entry_size(idx);
a61af66fc99e Initial load duke parents: diff changeset	1664
a61af66fc99e Initial load duke parents: diff changeset	1665 assert(size + ent_size <= cpool_size, "Size mismatch");
a61af66fc99e Initial load duke parents: diff changeset	1666
a61af66fc99e Initial load duke parents: diff changeset	1667 *bytes = tag;
a61af66fc99e Initial load duke parents: diff changeset	1668 DBG(printf("#%03hd tag=%03hd, ", idx, tag));
a61af66fc99e Initial load duke parents: diff changeset	1669 switch(tag) {
a61af66fc99e Initial load duke parents: diff changeset	1670 case JVM_CONSTANT_Invalid: {
a61af66fc99e Initial load duke parents: diff changeset	1671 DBG(printf("JVM_CONSTANT_Invalid"));
a61af66fc99e Initial load duke parents: diff changeset	1672 break;
a61af66fc99e Initial load duke parents: diff changeset	1673 }
a61af66fc99e Initial load duke parents: diff changeset	1674 case JVM_CONSTANT_Unicode: {
a61af66fc99e Initial load duke parents: diff changeset	1675 assert(false, "Wrong constant pool tag: JVM_CONSTANT_Unicode");
a61af66fc99e Initial load duke parents: diff changeset	1676 DBG(printf("JVM_CONSTANT_Unicode"));
a61af66fc99e Initial load duke parents: diff changeset	1677 break;
a61af66fc99e Initial load duke parents: diff changeset	1678 }
a61af66fc99e Initial load duke parents: diff changeset	1679 case JVM_CONSTANT_Utf8: {
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	1680 Symbol* sym = symbol_at(idx);
0 a61af66fc99e Initial load duke parents: diff changeset	1681 char* str = sym->as_utf8();
a61af66fc99e Initial load duke parents: diff changeset	1682 // Warning! It's crashing on x86 with len = sym->utf8_length()
a61af66fc99e Initial load duke parents: diff changeset	1683 int len = (int) strlen(str);
a61af66fc99e Initial load duke parents: diff changeset	1684 Bytes::put_Java_u2((address) (bytes+1), (u2) len);
a61af66fc99e Initial load duke parents: diff changeset	1685 for (int i = 0; i < len; i++) {
a61af66fc99e Initial load duke parents: diff changeset	1686 bytes[3+i] = (u1) str[i];
a61af66fc99e Initial load duke parents: diff changeset	1687 }
a61af66fc99e Initial load duke parents: diff changeset	1688 DBG(printf("JVM_CONSTANT_Utf8: %s ", str));
a61af66fc99e Initial load duke parents: diff changeset	1689 break;
a61af66fc99e Initial load duke parents: diff changeset	1690 }
a61af66fc99e Initial load duke parents: diff changeset	1691 case JVM_CONSTANT_Integer: {
a61af66fc99e Initial load duke parents: diff changeset	1692 jint val = int_at(idx);
a61af66fc99e Initial load duke parents: diff changeset	1693 Bytes::put_Java_u4((address) (bytes+1), (u4)&val);
a61af66fc99e Initial load duke parents: diff changeset	1694 break;
a61af66fc99e Initial load duke parents: diff changeset	1695 }
a61af66fc99e Initial load duke parents: diff changeset	1696 case JVM_CONSTANT_Float: {
a61af66fc99e Initial load duke parents: diff changeset	1697 jfloat val = float_at(idx);
a61af66fc99e Initial load duke parents: diff changeset	1698 Bytes::put_Java_u4((address) (bytes+1), (u4)&val);
a61af66fc99e Initial load duke parents: diff changeset	1699 break;
a61af66fc99e Initial load duke parents: diff changeset	1700 }
a61af66fc99e Initial load duke parents: diff changeset	1701 case JVM_CONSTANT_Long: {
a61af66fc99e Initial load duke parents: diff changeset	1702 jlong val = long_at(idx);
a61af66fc99e Initial load duke parents: diff changeset	1703 Bytes::put_Java_u8((address) (bytes+1), (u8)&val);
a61af66fc99e Initial load duke parents: diff changeset	1704 idx++; // Long takes two cpool slots
a61af66fc99e Initial load duke parents: diff changeset	1705 break;
a61af66fc99e Initial load duke parents: diff changeset	1706 }
a61af66fc99e Initial load duke parents: diff changeset	1707 case JVM_CONSTANT_Double: {
a61af66fc99e Initial load duke parents: diff changeset	1708 jdouble val = double_at(idx);
a61af66fc99e Initial load duke parents: diff changeset	1709 Bytes::put_Java_u8((address) (bytes+1), (u8)&val);
a61af66fc99e Initial load duke parents: diff changeset	1710 idx++; // Double takes two cpool slots
a61af66fc99e Initial load duke parents: diff changeset	1711 break;
a61af66fc99e Initial load duke parents: diff changeset	1712 }
a61af66fc99e Initial load duke parents: diff changeset	1713 case JVM_CONSTANT_Class:
a61af66fc99e Initial load duke parents: diff changeset	1714 case JVM_CONSTANT_UnresolvedClass:
a61af66fc99e Initial load duke parents: diff changeset	1715 case JVM_CONSTANT_UnresolvedClassInError: {
a61af66fc99e Initial load duke parents: diff changeset	1716 *bytes = JVM_CONSTANT_Class;
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	1717 Symbol* sym = klass_name_at(idx);
0 a61af66fc99e Initial load duke parents: diff changeset	1718 idx1 = tbl->symbol_to_value(sym);
a61af66fc99e Initial load duke parents: diff changeset	1719 assert(idx1 != 0, "Have not found a hashtable entry");
a61af66fc99e Initial load duke parents: diff changeset	1720 Bytes::put_Java_u2((address) (bytes+1), idx1);
a61af66fc99e Initial load duke parents: diff changeset	1721 DBG(printf("JVM_CONSTANT_Class: idx=#%03hd, %s", idx1, sym->as_utf8()));
a61af66fc99e Initial load duke parents: diff changeset	1722 break;
a61af66fc99e Initial load duke parents: diff changeset	1723 }
a61af66fc99e Initial load duke parents: diff changeset	1724 case JVM_CONSTANT_String: {
a61af66fc99e Initial load duke parents: diff changeset	1725 *bytes = JVM_CONSTANT_String;
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	1726 Symbol* sym = unresolved_string_at(idx);
0 a61af66fc99e Initial load duke parents: diff changeset	1727 idx1 = tbl->symbol_to_value(sym);
a61af66fc99e Initial load duke parents: diff changeset	1728 assert(idx1 != 0, "Have not found a hashtable entry");
a61af66fc99e Initial load duke parents: diff changeset	1729 Bytes::put_Java_u2((address) (bytes+1), idx1);
9060 cc32ccaaf47f 8003310: Enable -Wunused-function when compiling with gcc mikael parents: 8782 diff changeset	1730 DBG(printf("JVM_CONSTANT_String: idx=#%03hd, %s", idx1, sym->as_utf8()));
0 a61af66fc99e Initial load duke parents: diff changeset	1731 break;
a61af66fc99e Initial load duke parents: diff changeset	1732 }
a61af66fc99e Initial load duke parents: diff changeset	1733 case JVM_CONSTANT_Fieldref:
a61af66fc99e Initial load duke parents: diff changeset	1734 case JVM_CONSTANT_Methodref:
a61af66fc99e Initial load duke parents: diff changeset	1735 case JVM_CONSTANT_InterfaceMethodref: {
a61af66fc99e Initial load duke parents: diff changeset	1736 idx1 = uncached_klass_ref_index_at(idx);
a61af66fc99e Initial load duke parents: diff changeset	1737 idx2 = uncached_name_and_type_ref_index_at(idx);
a61af66fc99e Initial load duke parents: diff changeset	1738 Bytes::put_Java_u2((address) (bytes+1), idx1);
a61af66fc99e Initial load duke parents: diff changeset	1739 Bytes::put_Java_u2((address) (bytes+3), idx2);
a61af66fc99e Initial load duke parents: diff changeset	1740 DBG(printf("JVM_CONSTANT_Methodref: %hd %hd", idx1, idx2));
a61af66fc99e Initial load duke parents: diff changeset	1741 break;
a61af66fc99e Initial load duke parents: diff changeset	1742 }
a61af66fc99e Initial load duke parents: diff changeset	1743 case JVM_CONSTANT_NameAndType: {
a61af66fc99e Initial load duke parents: diff changeset	1744 idx1 = name_ref_index_at(idx);
a61af66fc99e Initial load duke parents: diff changeset	1745 idx2 = signature_ref_index_at(idx);
a61af66fc99e Initial load duke parents: diff changeset	1746 Bytes::put_Java_u2((address) (bytes+1), idx1);
a61af66fc99e Initial load duke parents: diff changeset	1747 Bytes::put_Java_u2((address) (bytes+3), idx2);
a61af66fc99e Initial load duke parents: diff changeset	1748 DBG(printf("JVM_CONSTANT_NameAndType: %hd %hd", idx1, idx2));
a61af66fc99e Initial load duke parents: diff changeset	1749 break;
a61af66fc99e Initial load duke parents: diff changeset	1750 }
a61af66fc99e Initial load duke parents: diff changeset	1751 case JVM_CONSTANT_ClassIndex: {
a61af66fc99e Initial load duke parents: diff changeset	1752 *bytes = JVM_CONSTANT_Class;
a61af66fc99e Initial load duke parents: diff changeset	1753 idx1 = klass_index_at(idx);
a61af66fc99e Initial load duke parents: diff changeset	1754 Bytes::put_Java_u2((address) (bytes+1), idx1);
a61af66fc99e Initial load duke parents: diff changeset	1755 DBG(printf("JVM_CONSTANT_ClassIndex: %hd", idx1));
a61af66fc99e Initial load duke parents: diff changeset	1756 break;
a61af66fc99e Initial load duke parents: diff changeset	1757 }
a61af66fc99e Initial load duke parents: diff changeset	1758 case JVM_CONSTANT_StringIndex: {
a61af66fc99e Initial load duke parents: diff changeset	1759 *bytes = JVM_CONSTANT_String;
a61af66fc99e Initial load duke parents: diff changeset	1760 idx1 = string_index_at(idx);
a61af66fc99e Initial load duke parents: diff changeset	1761 Bytes::put_Java_u2((address) (bytes+1), idx1);
a61af66fc99e Initial load duke parents: diff changeset	1762 DBG(printf("JVM_CONSTANT_StringIndex: %hd", idx1));
a61af66fc99e Initial load duke parents: diff changeset	1763 break;
a61af66fc99e Initial load duke parents: diff changeset	1764 }
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1765 case JVM_CONSTANT_MethodHandle:
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1766 case JVM_CONSTANT_MethodHandleInError: {
1602 136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	1767 *bytes = JVM_CONSTANT_MethodHandle;
12292 084b21cd0228 8025088: Missing cases for JVM_CONSTANT_MethodHandleInError cause crash if debugger steps into error-tagged method handle iklam parents: 12288 diff changeset	1768 int kind = method_handle_ref_kind_at_error_ok(idx);
084b21cd0228 8025088: Missing cases for JVM_CONSTANT_MethodHandleInError cause crash if debugger steps into error-tagged method handle iklam parents: 12288 diff changeset	1769 idx1 = method_handle_index_at_error_ok(idx);
1602 136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	1770 *(bytes+1) = (unsigned char) kind;
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	1771 Bytes::put_Java_u2((address) (bytes+2), idx1);
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	1772 DBG(printf("JVM_CONSTANT_MethodHandle: %d %hd", kind, idx1));
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	1773 break;
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	1774 }
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1775 case JVM_CONSTANT_MethodType:
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1776 case JVM_CONSTANT_MethodTypeInError: {
1602 136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	1777 *bytes = JVM_CONSTANT_MethodType;
12292 084b21cd0228 8025088: Missing cases for JVM_CONSTANT_MethodHandleInError cause crash if debugger steps into error-tagged method handle iklam parents: 12288 diff changeset	1778 idx1 = method_type_index_at_error_ok(idx);
1602 136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	1779 Bytes::put_Java_u2((address) (bytes+1), idx1);
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	1780 DBG(printf("JVM_CONSTANT_MethodType: %hd", idx1));
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	1781 break;
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	1782 }
1660 083fde3b838e 6964498: JSR 292 invokedynamic sites need local bootstrap methods jrose parents: 1602 diff changeset	1783 case JVM_CONSTANT_InvokeDynamic: {
2011 dad31fc330cd 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute jrose parents: 1972 diff changeset	1784 *bytes = tag;
dad31fc330cd 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute jrose parents: 1972 diff changeset	1785 idx1 = extract_low_short_from_int(*int_at_addr(idx));
dad31fc330cd 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute jrose parents: 1972 diff changeset	1786 idx2 = extract_high_short_from_int(*int_at_addr(idx));
dad31fc330cd 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute jrose parents: 1972 diff changeset	1787 assert(idx2 == invoke_dynamic_name_and_type_ref_index_at(idx), "correct half of u4");
1660 083fde3b838e 6964498: JSR 292 invokedynamic sites need local bootstrap methods jrose parents: 1602 diff changeset	1788 Bytes::put_Java_u2((address) (bytes+1), idx1);
083fde3b838e 6964498: JSR 292 invokedynamic sites need local bootstrap methods jrose parents: 1602 diff changeset	1789 Bytes::put_Java_u2((address) (bytes+3), idx2);
2011 dad31fc330cd 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute jrose parents: 1972 diff changeset	1790 DBG(printf("JVM_CONSTANT_InvokeDynamic: %hd %hd", idx1, idx2));
1660 083fde3b838e 6964498: JSR 292 invokedynamic sites need local bootstrap methods jrose parents: 1602 diff changeset	1791 break;
083fde3b838e 6964498: JSR 292 invokedynamic sites need local bootstrap methods jrose parents: 1602 diff changeset	1792 }
0 a61af66fc99e Initial load duke parents: diff changeset	1793 }
a61af66fc99e Initial load duke parents: diff changeset	1794 DBG(printf("\n"));
a61af66fc99e Initial load duke parents: diff changeset	1795 bytes += ent_size;
a61af66fc99e Initial load duke parents: diff changeset	1796 size += ent_size;
a61af66fc99e Initial load duke parents: diff changeset	1797 }
a61af66fc99e Initial load duke parents: diff changeset	1798 assert(size == cpool_size, "Size mismatch");
a61af66fc99e Initial load duke parents: diff changeset	1799
a61af66fc99e Initial load duke parents: diff changeset	1800 // Keep temorarily for debugging until it's stable.
a61af66fc99e Initial load duke parents: diff changeset	1801 DBG(print_cpool_bytes(cnt, start_bytes));
a61af66fc99e Initial load duke parents: diff changeset	1802 return (int)(bytes - start_bytes);
a61af66fc99e Initial load duke parents: diff changeset	1803 } /* end copy_cpool_bytes */
a61af66fc99e Initial load duke parents: diff changeset	1804
9060 cc32ccaaf47f 8003310: Enable -Wunused-function when compiling with gcc mikael parents: 8782 diff changeset	1805 #undef DBG
cc32ccaaf47f 8003310: Enable -Wunused-function when compiling with gcc mikael parents: 8782 diff changeset	1806
0 a61af66fc99e Initial load duke parents: diff changeset	1807
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1808 void ConstantPool::set_on_stack(const bool value) {
7949 5daaddd917a1 8006040: NPG: on_stack processing wastes space in ConstantPool coleenp parents: 7624 diff changeset	1809 if (value) {
5daaddd917a1 8006040: NPG: on_stack processing wastes space in ConstantPool coleenp parents: 7624 diff changeset	1810 _flags \|= _on_stack;
5daaddd917a1 8006040: NPG: on_stack processing wastes space in ConstantPool coleenp parents: 7624 diff changeset	1811 } else {
5daaddd917a1 8006040: NPG: on_stack processing wastes space in ConstantPool coleenp parents: 7624 diff changeset	1812 _flags &= ~_on_stack;
5daaddd917a1 8006040: NPG: on_stack processing wastes space in ConstantPool coleenp parents: 7624 diff changeset	1813 }
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1814 if (value) MetadataOnStackMark::record(this);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1815 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1816
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1817 // JSR 292 support for patching constant pool oops after the class is linked and
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1818 // the oop array for resolved references are created.
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1819 // We can't do this during classfile parsing, which is how the other indexes are
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1820 // patched. The other patches are applied early for some error checking
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1821 // so only defer the pseudo_strings.
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1822 void ConstantPool::patch_resolved_references(
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1823 GrowableArray<Handle>* cp_patches) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1824 assert(EnableInvokeDynamic, "");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1825 for (int index = 1; index < cp_patches->length(); index++) { // Index 0 is unused
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1826 Handle patch = cp_patches->at(index);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1827 if (patch.not_null()) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1828 assert (tag_at(index).is_string(), "should only be string left");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1829 // Patching a string means pre-resolving it.
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1830 // The spelling in the constant pool is ignored.
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1831 // The constant reference may be any object whatever.
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1832 // If it is not a real interned string, the constant is referred
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1833 // to as a "pseudo-string", and must be presented to the CP
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1834 // explicitly, because it may require scavenging.
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1835 int obj_index = cp_to_object_index(index);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1836 pseudo_string_at_put(index, obj_index, patch());
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1837 DEBUG_ONLY(cp_patches->at_put(index, Handle());)
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1838 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1839 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1840 #ifdef ASSERT
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1841 // Ensure that all the patches have been used.
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1842 for (int index = 0; index < cp_patches->length(); index++) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1843 assert(cp_patches->at(index).is_null(),
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1844 err_msg("Unused constant pool patch at %d in class file %s",
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1845 index,
6940 18fb7da42534 8000725: NPG: method_holder() and pool_holder() and pool_holder field should be InstanceKlass coleenp parents: 6934 diff changeset	1846 pool_holder()->external_name()));
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1847 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1848 #endif // ASSERT
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1849 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1850
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1851 #ifndef PRODUCT
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1852
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1853 // CompileTheWorld support. Preload all classes loaded references in the passed in constantpool
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1854 void ConstantPool::preload_and_initialize_all_classes(ConstantPool* obj, TRAPS) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1855 guarantee(obj->is_constantPool(), "object must be constant pool");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1856 constantPoolHandle cp(THREAD, (ConstantPool*)obj);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1857 guarantee(cp->pool_holder() != NULL, "must be fully loaded");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1858
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1859 for (int i = 0; i< cp->length(); i++) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1860 if (cp->tag_at(i).is_unresolved_klass()) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1861 // This will force loading of the class
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1862 Klass* klass = cp->klass_at(i, CHECK);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1863 if (klass->oop_is_instance()) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1864 // Force initialization of class
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1865 InstanceKlass::cast(klass)->initialize(CHECK);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1866 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1867 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1868 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1869 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1870
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1871 #endif
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1872
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1873
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1874 // Printing
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1875
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1876 void ConstantPool::print_on(outputStream* st) const {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1877 EXCEPTION_MARK;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1878 assert(is_constantPool(), "must be constantPool");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1879 st->print_cr(internal_name());
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1880 if (flags() != 0) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1881 st->print(" - flags: 0x%x", flags());
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1882 if (has_preresolution()) st->print(" has_preresolution");
7949 5daaddd917a1 8006040: NPG: on_stack processing wastes space in ConstantPool coleenp parents: 7624 diff changeset	1883 if (on_stack()) st->print(" on_stack");
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1884 st->cr();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1885 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1886 if (pool_holder() != NULL) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1887 st->print_cr(" - holder: " INTPTR_FORMAT, pool_holder());
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1888 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1889 st->print_cr(" - cache: " INTPTR_FORMAT, cache());
12316 190899198332 7195622: CheckUnhandledOops has limited usefulness now hseigel parents: 12292 diff changeset	1890 st->print_cr(" - resolved_references: " INTPTR_FORMAT, (void *)resolved_references());
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1891 st->print_cr(" - reference_map: " INTPTR_FORMAT, reference_map());
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1892
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1893 for (int index = 1; index < length(); index++) { // Index 0 is unused
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1894 ((ConstantPool*)this)->print_entry_on(index, st);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1895 switch (tag_at(index).value()) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1896 case JVM_CONSTANT_Long :
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1897 case JVM_CONSTANT_Double :
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1898 index++; // Skip entry following eigth-byte constant
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1899 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1900
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1901 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1902 st->cr();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1903 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1904
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1905 // Print one constant pool entry
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1906 void ConstantPool::print_entry_on(const int index, outputStream* st) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1907 EXCEPTION_MARK;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1908 st->print(" - %3d : ", index);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1909 tag_at(index).print_on(st);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1910 st->print(" : ");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1911 switch (tag_at(index).value()) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1912 case JVM_CONSTANT_Class :
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1913 { Klass* k = klass_at(index, CATCH);
8782 c3c64a973559 8009593: [parfait] Null pointer deference in hotspot/src/share/vm/oops/constantPool.cpp morris parents: 8104 diff changeset	1914 guarantee(k != NULL, "need klass");
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1915 k->print_value_on(st);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1916 st->print(" {0x%lx}", (address)k);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1917 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1918 break;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1919 case JVM_CONSTANT_Fieldref :
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1920 case JVM_CONSTANT_Methodref :
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1921 case JVM_CONSTANT_InterfaceMethodref :
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1922 st->print("klass_index=%d", uncached_klass_ref_index_at(index));
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1923 st->print(" name_and_type_index=%d", uncached_name_and_type_ref_index_at(index));
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1924 break;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1925 case JVM_CONSTANT_String :
8104 f16e75e0cf11 8000797: NPG: is_pseudo_string_at() doesn't work coleenp parents: 7964 diff changeset	1926 if (is_pseudo_string_at(index)) {
f16e75e0cf11 8000797: NPG: is_pseudo_string_at() doesn't work coleenp parents: 7964 diff changeset	1927 oop anObj = pseudo_string_at(index);
f16e75e0cf11 8000797: NPG: is_pseudo_string_at() doesn't work coleenp parents: 7964 diff changeset	1928 anObj->print_value_on(st);
f16e75e0cf11 8000797: NPG: is_pseudo_string_at() doesn't work coleenp parents: 7964 diff changeset	1929 st->print(" {0x%lx}", (address)anObj);
f16e75e0cf11 8000797: NPG: is_pseudo_string_at() doesn't work coleenp parents: 7964 diff changeset	1930 } else {
f16e75e0cf11 8000797: NPG: is_pseudo_string_at() doesn't work coleenp parents: 7964 diff changeset	1931 unresolved_string_at(index)->print_value_on(st);
f16e75e0cf11 8000797: NPG: is_pseudo_string_at() doesn't work coleenp parents: 7964 diff changeset	1932 }
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1933 break;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1934 case JVM_CONSTANT_Integer :
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1935 st->print("%d", int_at(index));
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1936 break;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1937 case JVM_CONSTANT_Float :
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1938 st->print("%f", float_at(index));
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1939 break;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1940 case JVM_CONSTANT_Long :
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1941 st->print_jlong(long_at(index));
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1942 break;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1943 case JVM_CONSTANT_Double :
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1944 st->print("%lf", double_at(index));
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1945 break;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1946 case JVM_CONSTANT_NameAndType :
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1947 st->print("name_index=%d", name_ref_index_at(index));
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1948 st->print(" signature_index=%d", signature_ref_index_at(index));
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1949 break;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1950 case JVM_CONSTANT_Utf8 :
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1951 symbol_at(index)->print_value_on(st);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1952 break;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1953 case JVM_CONSTANT_UnresolvedClass : // fall-through
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1954 case JVM_CONSTANT_UnresolvedClassInError: {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1955 // unresolved_klass_at requires lock or safe world.
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1956 CPSlot entry = slot_at(index);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1957 if (entry.is_resolved()) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1958 entry.get_klass()->print_value_on(st);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1959 } else {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1960 entry.get_symbol()->print_value_on(st);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1961 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1962 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1963 break;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1964 case JVM_CONSTANT_MethodHandle :
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1965 case JVM_CONSTANT_MethodHandleInError :
12292 084b21cd0228 8025088: Missing cases for JVM_CONSTANT_MethodHandleInError cause crash if debugger steps into error-tagged method handle iklam parents: 12288 diff changeset	1966 st->print("ref_kind=%d", method_handle_ref_kind_at_error_ok(index));
084b21cd0228 8025088: Missing cases for JVM_CONSTANT_MethodHandleInError cause crash if debugger steps into error-tagged method handle iklam parents: 12288 diff changeset	1967 st->print(" ref_index=%d", method_handle_index_at_error_ok(index));
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1968 break;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1969 case JVM_CONSTANT_MethodType :
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1970 case JVM_CONSTANT_MethodTypeInError :
12292 084b21cd0228 8025088: Missing cases for JVM_CONSTANT_MethodHandleInError cause crash if debugger steps into error-tagged method handle iklam parents: 12288 diff changeset	1971 st->print("signature_index=%d", method_type_index_at_error_ok(index));
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1972 break;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1973 case JVM_CONSTANT_InvokeDynamic :
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1974 {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1975 st->print("bootstrap_method_index=%d", invoke_dynamic_bootstrap_method_ref_index_at(index));
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1976 st->print(" name_and_type_index=%d", invoke_dynamic_name_and_type_ref_index_at(index));
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1977 int argc = invoke_dynamic_argument_count_at(index);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1978 if (argc > 0) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1979 for (int arg_i = 0; arg_i < argc; arg_i++) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1980 int arg = invoke_dynamic_argument_index_at(index, arg_i);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1981 st->print((arg_i == 0 ? " arguments={%d" : ", %d"), arg);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1982 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1983 st->print("}");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1984 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1985 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1986 break;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1987 default:
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1988 ShouldNotReachHere();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1989 break;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1990 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1991 st->cr();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1992 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1993
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1994 void ConstantPool::print_value_on(outputStream* st) const {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1995 assert(is_constantPool(), "must be constantPool");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1996 st->print("constant pool [%d]", length());
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1997 if (has_preresolution()) st->print("/preresolution");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1998 if (operands() != NULL) st->print("/operands[%d]", operands()->length());
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1999 print_address_on(st);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2000 st->print(" for ");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2001 pool_holder()->print_value_on(st);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2002 if (pool_holder() != NULL) {
6940 18fb7da42534 8000725: NPG: method_holder() and pool_holder() and pool_holder field should be InstanceKlass coleenp parents: 6934 diff changeset	2003 bool extra = (pool_holder()->constants() != this);
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2004 if (extra) st->print(" (extra)");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2005 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2006 if (cache() != NULL) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2007 st->print(" cache=" PTR_FORMAT, cache());
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2008 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2009 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2010
7956 16fb9f942703 6479360: PrintClassHistogram improvements acorn parents: 7949 diff changeset	2011 #if INCLUDE_SERVICES
16fb9f942703 6479360: PrintClassHistogram improvements acorn parents: 7949 diff changeset	2012 // Size Statistics
16fb9f942703 6479360: PrintClassHistogram improvements acorn parents: 7949 diff changeset	2013 void ConstantPool::collect_statistics(KlassSizeStats *sz) const {
16fb9f942703 6479360: PrintClassHistogram improvements acorn parents: 7949 diff changeset	2014 sz->_cp_all_bytes += (sz->_cp_bytes = sz->count(this));
16fb9f942703 6479360: PrintClassHistogram improvements acorn parents: 7949 diff changeset	2015 sz->_cp_all_bytes += (sz->_cp_tags_bytes = sz->count_array(tags()));
16fb9f942703 6479360: PrintClassHistogram improvements acorn parents: 7949 diff changeset	2016 sz->_cp_all_bytes += (sz->_cp_cache_bytes = sz->count(cache()));
16fb9f942703 6479360: PrintClassHistogram improvements acorn parents: 7949 diff changeset	2017 sz->_cp_all_bytes += (sz->_cp_operands_bytes = sz->count_array(operands()));
16fb9f942703 6479360: PrintClassHistogram improvements acorn parents: 7949 diff changeset	2018 sz->_cp_all_bytes += (sz->_cp_refmap_bytes = sz->count_array(reference_map()));
16fb9f942703 6479360: PrintClassHistogram improvements acorn parents: 7949 diff changeset	2019
16fb9f942703 6479360: PrintClassHistogram improvements acorn parents: 7949 diff changeset	2020 sz->_ro_bytes += sz->_cp_operands_bytes + sz->_cp_tags_bytes +
16fb9f942703 6479360: PrintClassHistogram improvements acorn parents: 7949 diff changeset	2021 sz->_cp_refmap_bytes;
16fb9f942703 6479360: PrintClassHistogram improvements acorn parents: 7949 diff changeset	2022 sz->_rw_bytes += sz->_cp_bytes + sz->_cp_cache_bytes;
16fb9f942703 6479360: PrintClassHistogram improvements acorn parents: 7949 diff changeset	2023 }
16fb9f942703 6479360: PrintClassHistogram improvements acorn parents: 7949 diff changeset	2024 #endif // INCLUDE_SERVICES
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2025
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2026 // Verification
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2027
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2028 void ConstantPool::verify_on(outputStream* st) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2029 guarantee(is_constantPool(), "object must be constant pool");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2030 for (int i = 0; i< length(); i++) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2031 constantTag tag = tag_at(i);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2032 CPSlot entry = slot_at(i);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2033 if (tag.is_klass()) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2034 if (entry.is_resolved()) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2035 guarantee(entry.get_klass()->is_klass(), "should be klass");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2036 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2037 } else if (tag.is_unresolved_klass()) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2038 if (entry.is_resolved()) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2039 guarantee(entry.get_klass()->is_klass(), "should be klass");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2040 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2041 } else if (tag.is_symbol()) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2042 guarantee(entry.get_symbol()->refcount() != 0, "should have nonzero reference count");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2043 } else if (tag.is_string()) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2044 guarantee(entry.get_symbol()->refcount() != 0, "should have nonzero reference count");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2045 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2046 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2047 if (cache() != NULL) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2048 // Note: cache() can be NULL before a class is completely setup or
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2049 // in temporary constant pools used during constant pool merging
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2050 guarantee(cache()->is_constantPoolCache(), "should be constant pool cache");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2051 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2052 if (pool_holder() != NULL) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2053 // Note: pool_holder() can be NULL in temporary constant pools
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2054 // used during constant pool merging
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2055 guarantee(pool_holder()->is_klass(), "should be klass");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2056 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2057 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2058
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2059
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	2060 void SymbolHashMap::add_entry(Symbol* sym, u2 value) {
0 a61af66fc99e Initial load duke parents: diff changeset	2061 char *str = sym->as_utf8();
a61af66fc99e Initial load duke parents: diff changeset	2062 unsigned int hash = compute_hash(str, sym->utf8_length());
a61af66fc99e Initial load duke parents: diff changeset	2063 unsigned int index = hash % table_size();
a61af66fc99e Initial load duke parents: diff changeset	2064
a61af66fc99e Initial load duke parents: diff changeset	2065 // check if already in map
a61af66fc99e Initial load duke parents: diff changeset	2066 // we prefer the first entry since it is more likely to be what was used in
a61af66fc99e Initial load duke parents: diff changeset	2067 // the class file
a61af66fc99e Initial load duke parents: diff changeset	2068 for (SymbolHashMapEntry *en = bucket(index); en != NULL; en = en->next()) {
a61af66fc99e Initial load duke parents: diff changeset	2069 assert(en->symbol() != NULL, "SymbolHashMapEntry symbol is NULL");
a61af66fc99e Initial load duke parents: diff changeset	2070 if (en->hash() == hash && en->symbol() == sym) {
a61af66fc99e Initial load duke parents: diff changeset	2071 return; // already there
a61af66fc99e Initial load duke parents: diff changeset	2072 }
a61af66fc99e Initial load duke parents: diff changeset	2073 }
a61af66fc99e Initial load duke parents: diff changeset	2074
a61af66fc99e Initial load duke parents: diff changeset	2075 SymbolHashMapEntry* entry = new SymbolHashMapEntry(hash, sym, value);
a61af66fc99e Initial load duke parents: diff changeset	2076 entry->set_next(bucket(index));
a61af66fc99e Initial load duke parents: diff changeset	2077 _buckets[index].set_entry(entry);
a61af66fc99e Initial load duke parents: diff changeset	2078 assert(entry->symbol() != NULL, "SymbolHashMapEntry symbol is NULL");
a61af66fc99e Initial load duke parents: diff changeset	2079 }
a61af66fc99e Initial load duke parents: diff changeset	2080
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	2081 SymbolHashMapEntry* SymbolHashMap::find_entry(Symbol* sym) {
0 a61af66fc99e Initial load duke parents: diff changeset	2082 assert(sym != NULL, "SymbolHashMap::find_entry - symbol is NULL");
a61af66fc99e Initial load duke parents: diff changeset	2083 char *str = sym->as_utf8();
a61af66fc99e Initial load duke parents: diff changeset	2084 int len = sym->utf8_length();
a61af66fc99e Initial load duke parents: diff changeset	2085 unsigned int hash = SymbolHashMap::compute_hash(str, len);
a61af66fc99e Initial load duke parents: diff changeset	2086 unsigned int index = hash % table_size();
a61af66fc99e Initial load duke parents: diff changeset	2087 for (SymbolHashMapEntry *en = bucket(index); en != NULL; en = en->next()) {
a61af66fc99e Initial load duke parents: diff changeset	2088 assert(en->symbol() != NULL, "SymbolHashMapEntry symbol is NULL");
a61af66fc99e Initial load duke parents: diff changeset	2089 if (en->hash() == hash && en->symbol() == sym) {
a61af66fc99e Initial load duke parents: diff changeset	2090 return en;
a61af66fc99e Initial load duke parents: diff changeset	2091 }
a61af66fc99e Initial load duke parents: diff changeset	2092 }
a61af66fc99e Initial load duke parents: diff changeset	2093 return NULL;
a61af66fc99e Initial load duke parents: diff changeset	2094 }

Mercurial > hg > truffle

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