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

annotate src/share/vm/oops/constantPool.cpp @ 9126:bc26f978b0ce

HotSpotResolvedObjectType: implement hasFinalizeSubclass() correctly don't use the (wrong) cached value, but ask the runtime on each request. Fixes regression on xml.* benchmarks @ specjvm2008. The problem was: After the constructor of Object was deoptimized due to an assumption violation, it was recompiled again after some time. However, on recompilation, the value of hasFinalizeSubclass for the class was not updated and it was compiled again with a, now wrong, assumption, which then triggers deoptimization again. This was repeated until it hit the recompilation limit (defined by PerMethodRecompilationCutoff), and therefore only executed by the interpreter from now on, causing the performance regression.

author	Bernhard Urban <bernhard.urban@jku.at>
date	Mon, 15 Apr 2013 19:54:58 +0200
parents	89e4d67fdd2a
children	836a62f43af9

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.
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	57 return new (loader_data, size, false, THREAD) ConstantPool(tags);
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);
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	72 set_lock(new Monitor(Monitor::nonleaf + 2, "A constant pool lock"));
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();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	98
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	99 delete _lock;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	100 set_lock(NULL);
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,
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	114 TRAPS) {
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
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	119 // invokedynamic resolved_reference entries. The constant pool cache index
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	120 // has the mapping back to both the constant pool and to the resolved
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	121 // reference index.
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	122 if (constant_pool_map_length > 0) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	123 Array<u2>* om = MetadataFactory::new_array<u2>(loader_data, map_length, CHECK);
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 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	157
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	158 // Also need to recreate the mutex. Make sure this matches the constructor
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	159 set_lock(new Monitor(Monitor::nonleaf + 2, "A constant pool lock"));
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);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	170 set_lock(NULL);
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.
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	175 for (int i = 0; i< reference_map()->length(); i++) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	176 if (reference_map()->at(i) == cp_index) return i;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	177 // Zero entry is divider between constant pool indices for strings,
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	178 // method handles and method types. After that the index is a constant
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	179 // pool cache index for invokedynamic. Stop when zero (which can never
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	180 // be a constant pool index)
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	181 if (reference_map()->at(i) == 0) break;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	182 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	183 // We might not find the index.
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	184 return _no_index_sentinel;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	185 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	186
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	187 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	188 // A resolved constantPool entry will contain a Klass, otherwise a Symbol.
0 a61af66fc99e Initial load duke parents: diff changeset	189 // 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	190 // tag is not updated atomicly.
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	191
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	192 CPSlot entry = this_oop->slot_at(which);
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	193 if (entry.is_resolved()) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	194 assert(entry.get_klass()->is_klass(), "must be");
0 a61af66fc99e Initial load duke parents: diff changeset	195 // Already resolved - return entry.
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	196 return entry.get_klass();
0 a61af66fc99e Initial load duke parents: diff changeset	197 }
a61af66fc99e Initial load duke parents: diff changeset	198
a61af66fc99e Initial load duke parents: diff changeset	199 // 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	200 // already has updated the object
a61af66fc99e Initial load duke parents: diff changeset	201 assert(THREAD->is_Java_thread(), "must be a Java thread");
a61af66fc99e Initial load duke parents: diff changeset	202 bool do_resolve = false;
a61af66fc99e Initial load duke parents: diff changeset	203 bool in_error = false;
a61af66fc99e Initial load duke parents: diff changeset	204
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	205 // 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	206 // until the loader_data is registered.
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	207 Handle mirror_handle;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	208
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	209 Symbol* name = NULL;
0 a61af66fc99e Initial load duke parents: diff changeset	210 Handle loader;
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	211 { MonitorLockerEx ml(this_oop->lock());
0 a61af66fc99e Initial load duke parents: diff changeset	212
a61af66fc99e Initial load duke parents: diff changeset	213 if (this_oop->tag_at(which).is_unresolved_klass()) {
a61af66fc99e Initial load duke parents: diff changeset	214 if (this_oop->tag_at(which).is_unresolved_klass_in_error()) {
a61af66fc99e Initial load duke parents: diff changeset	215 in_error = true;
a61af66fc99e Initial load duke parents: diff changeset	216 } else {
a61af66fc99e Initial load duke parents: diff changeset	217 do_resolve = true;
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	218 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	219 loader = Handle(THREAD, this_oop->pool_holder()->class_loader());
0 a61af66fc99e Initial load duke parents: diff changeset	220 }
a61af66fc99e Initial load duke parents: diff changeset	221 }
a61af66fc99e Initial load duke parents: diff changeset	222 } // unlocking constantPool
a61af66fc99e Initial load duke parents: diff changeset	223
a61af66fc99e Initial load duke parents: diff changeset	224
a61af66fc99e Initial load duke parents: diff changeset	225 // The original attempt to resolve this constant pool entry failed so find the
a61af66fc99e Initial load duke parents: diff changeset	226 // original error and throw it again (JVMS 5.4.3).
a61af66fc99e Initial load duke parents: diff changeset	227 if (in_error) {
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	228 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	229 guarantee(error != (Symbol*)NULL, "tag mismatch with resolution error table");
0 a61af66fc99e Initial load duke parents: diff changeset	230 ResourceMark rm;
a61af66fc99e Initial load duke parents: diff changeset	231 // exception text will be the class name
a61af66fc99e Initial load duke parents: diff changeset	232 const char* className = this_oop->unresolved_klass_at(which)->as_C_string();
a61af66fc99e Initial load duke parents: diff changeset	233 THROW_MSG_0(error, className);
a61af66fc99e Initial load duke parents: diff changeset	234 }
a61af66fc99e Initial load duke parents: diff changeset	235
a61af66fc99e Initial load duke parents: diff changeset	236 if (do_resolve) {
a61af66fc99e Initial load duke parents: diff changeset	237 // 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	238 oop protection_domain = this_oop->pool_holder()->protection_domain();
0 a61af66fc99e Initial load duke parents: diff changeset	239 Handle h_prot (THREAD, protection_domain);
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	240 Klass* k_oop = SystemDictionary::resolve_or_fail(name, loader, h_prot, true, THREAD);
0 a61af66fc99e Initial load duke parents: diff changeset	241 KlassHandle k;
a61af66fc99e Initial load duke parents: diff changeset	242 if (!HAS_PENDING_EXCEPTION) {
a61af66fc99e Initial load duke parents: diff changeset	243 k = KlassHandle(THREAD, k_oop);
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	244 // preserve the resolved klass.
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	245 mirror_handle = Handle(THREAD, k_oop->java_mirror());
0 a61af66fc99e Initial load duke parents: diff changeset	246 // Do access check for klasses
a61af66fc99e Initial load duke parents: diff changeset	247 verify_constant_pool_resolve(this_oop, k, THREAD);
a61af66fc99e Initial load duke parents: diff changeset	248 }
a61af66fc99e Initial load duke parents: diff changeset	249
a61af66fc99e Initial load duke parents: diff changeset	250 // Failed to resolve class. We must record the errors so that subsequent attempts
a61af66fc99e Initial load duke parents: diff changeset	251 // to resolve this constant pool entry fail with the same error (JVMS 5.4.3).
a61af66fc99e Initial load duke parents: diff changeset	252 if (HAS_PENDING_EXCEPTION) {
a61af66fc99e Initial load duke parents: diff changeset	253 ResourceMark rm;
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	254 Symbol* error = PENDING_EXCEPTION->klass()->name();
0 a61af66fc99e Initial load duke parents: diff changeset	255
a61af66fc99e Initial load duke parents: diff changeset	256 bool throw_orig_error = false;
a61af66fc99e Initial load duke parents: diff changeset	257 {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	258 MonitorLockerEx ml(this_oop->lock());
0 a61af66fc99e Initial load duke parents: diff changeset	259
a61af66fc99e Initial load duke parents: diff changeset	260 // some other thread has beaten us and has resolved the class.
a61af66fc99e Initial load duke parents: diff changeset	261 if (this_oop->tag_at(which).is_klass()) {
a61af66fc99e Initial load duke parents: diff changeset	262 CLEAR_PENDING_EXCEPTION;
a61af66fc99e Initial load duke parents: diff changeset	263 entry = this_oop->resolved_klass_at(which);
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	264 return entry.get_klass();
0 a61af66fc99e Initial load duke parents: diff changeset	265 }
a61af66fc99e Initial load duke parents: diff changeset	266
a61af66fc99e Initial load duke parents: diff changeset	267 if (!PENDING_EXCEPTION->
1142 4ce7240d622c 6914300: ciEnv should export all well known classes never parents: 1059 diff changeset	268 is_a(SystemDictionary::LinkageError_klass())) {
0 a61af66fc99e Initial load duke parents: diff changeset	269 // Just throw the exception and don't prevent these classes from
a61af66fc99e Initial load duke parents: diff changeset	270 // being loaded due to virtual machine errors like StackOverflow
a61af66fc99e Initial load duke parents: diff changeset	271 // and OutOfMemoryError, etc, or if the thread was hit by stop()
a61af66fc99e Initial load duke parents: diff changeset	272 // Needs clarification to section 5.4.3 of the VM spec (see 6308271)
a61af66fc99e Initial load duke parents: diff changeset	273 }
a61af66fc99e Initial load duke parents: diff changeset	274 else if (!this_oop->tag_at(which).is_unresolved_klass_in_error()) {
a61af66fc99e Initial load duke parents: diff changeset	275 SystemDictionary::add_resolution_error(this_oop, which, error);
a61af66fc99e Initial load duke parents: diff changeset	276 this_oop->tag_at_put(which, JVM_CONSTANT_UnresolvedClassInError);
a61af66fc99e Initial load duke parents: diff changeset	277 } else {
a61af66fc99e Initial load duke parents: diff changeset	278 // 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	279 error = SystemDictionary::find_resolution_error(this_oop, which);
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	280 assert(error != NULL, "checking");
0 a61af66fc99e Initial load duke parents: diff changeset	281 throw_orig_error = true;
a61af66fc99e Initial load duke parents: diff changeset	282 }
a61af66fc99e Initial load duke parents: diff changeset	283 } // unlocked
a61af66fc99e Initial load duke parents: diff changeset	284
a61af66fc99e Initial load duke parents: diff changeset	285 if (throw_orig_error) {
a61af66fc99e Initial load duke parents: diff changeset	286 CLEAR_PENDING_EXCEPTION;
a61af66fc99e Initial load duke parents: diff changeset	287 ResourceMark rm;
a61af66fc99e Initial load duke parents: diff changeset	288 const char* className = this_oop->unresolved_klass_at(which)->as_C_string();
a61af66fc99e Initial load duke parents: diff changeset	289 THROW_MSG_0(error, className);
a61af66fc99e Initial load duke parents: diff changeset	290 }
a61af66fc99e Initial load duke parents: diff changeset	291
a61af66fc99e Initial load duke parents: diff changeset	292 return 0;
a61af66fc99e Initial load duke parents: diff changeset	293 }
a61af66fc99e Initial load duke parents: diff changeset	294
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	295 if (TraceClassResolution && !k()->oop_is_array()) {
0 a61af66fc99e Initial load duke parents: diff changeset	296 // skip resolving the constant pool so that this code get's
a61af66fc99e Initial load duke parents: diff changeset	297 // called the next time some bytecodes refer to this class.
a61af66fc99e Initial load duke parents: diff changeset	298 ResourceMark rm;
a61af66fc99e Initial load duke parents: diff changeset	299 int line_number = -1;
a61af66fc99e Initial load duke parents: diff changeset	300 const char * source_file = NULL;
a61af66fc99e Initial load duke parents: diff changeset	301 if (JavaThread::current()->has_last_Java_frame()) {
a61af66fc99e Initial load duke parents: diff changeset	302 // try to identify the method which called this function.
a61af66fc99e Initial load duke parents: diff changeset	303 vframeStream vfst(JavaThread::current());
a61af66fc99e Initial load duke parents: diff changeset	304 if (!vfst.at_end()) {
a61af66fc99e Initial load duke parents: diff changeset	305 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	306 Symbol* s = vfst.method()->method_holder()->source_file_name();
0 a61af66fc99e Initial load duke parents: diff changeset	307 if (s != NULL) {
a61af66fc99e Initial load duke parents: diff changeset	308 source_file = s->as_C_string();
a61af66fc99e Initial load duke parents: diff changeset	309 }
a61af66fc99e Initial load duke parents: diff changeset	310 }
a61af66fc99e Initial load duke parents: diff changeset	311 }
a61af66fc99e Initial load duke parents: diff changeset	312 if (k() != this_oop->pool_holder()) {
a61af66fc99e Initial load duke parents: diff changeset	313 // only print something if the classes are different
a61af66fc99e Initial load duke parents: diff changeset	314 if (source_file != NULL) {
a61af66fc99e Initial load duke parents: diff changeset	315 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	316 this_oop->pool_holder()->external_name(),
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	317 InstanceKlass::cast(k())->external_name(), source_file, line_number);
0 a61af66fc99e Initial load duke parents: diff changeset	318 } else {
a61af66fc99e Initial load duke parents: diff changeset	319 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	320 this_oop->pool_holder()->external_name(),
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	321 InstanceKlass::cast(k())->external_name());
0 a61af66fc99e Initial load duke parents: diff changeset	322 }
a61af66fc99e Initial load duke parents: diff changeset	323 }
a61af66fc99e Initial load duke parents: diff changeset	324 return k();
a61af66fc99e Initial load duke parents: diff changeset	325 } else {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	326 MonitorLockerEx ml(this_oop->lock());
0 a61af66fc99e Initial load duke parents: diff changeset	327 // Only updated constant pool - if it is resolved.
a61af66fc99e Initial load duke parents: diff changeset	328 do_resolve = this_oop->tag_at(which).is_unresolved_klass();
a61af66fc99e Initial load duke parents: diff changeset	329 if (do_resolve) {
6940 18fb7da42534 8000725: NPG: method_holder() and pool_holder() and pool_holder field should be InstanceKlass coleenp parents: 6934 diff changeset	330 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	331 this_key->record_dependency(k(), CHECK_NULL); // Can throw OOM
0 a61af66fc99e Initial load duke parents: diff changeset	332 this_oop->klass_at_put(which, k());
a61af66fc99e Initial load duke parents: diff changeset	333 }
a61af66fc99e Initial load duke parents: diff changeset	334 }
a61af66fc99e Initial load duke parents: diff changeset	335 }
a61af66fc99e Initial load duke parents: diff changeset	336
a61af66fc99e Initial load duke parents: diff changeset	337 entry = this_oop->resolved_klass_at(which);
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	338 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	339 return entry.get_klass();
0 a61af66fc99e Initial load duke parents: diff changeset	340 }
a61af66fc99e Initial load duke parents: diff changeset	341
a61af66fc99e Initial load duke parents: diff changeset	342
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	343 // Does not update ConstantPool* - to avoid any exception throwing. Used
0 a61af66fc99e Initial load duke parents: diff changeset	344 // by compiler and exception handling. Also used to avoid classloads for
a61af66fc99e Initial load duke parents: diff changeset	345 // instanceof operations. Returns NULL if the class has not been loaded or
a61af66fc99e Initial load duke parents: diff changeset	346 // if the verification of constant pool failed
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	347 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	348 CPSlot entry = this_oop->slot_at(which);
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	349 if (entry.is_resolved()) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	350 assert(entry.get_klass()->is_klass(), "must be");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	351 return entry.get_klass();
0 a61af66fc99e Initial load duke parents: diff changeset	352 } else {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	353 assert(entry.is_unresolved(), "must be either symbol or klass");
0 a61af66fc99e Initial load duke parents: diff changeset	354 Thread *thread = Thread::current();
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	355 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	356 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	357 oop protection_domain = this_oop->pool_holder()->protection_domain();
0 a61af66fc99e Initial load duke parents: diff changeset	358 Handle h_prot (thread, protection_domain);
a61af66fc99e Initial load duke parents: diff changeset	359 Handle h_loader (thread, loader);
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	360 Klass* k = SystemDictionary::find(name, h_loader, h_prot, thread);
0 a61af66fc99e Initial load duke parents: diff changeset	361
a61af66fc99e Initial load duke parents: diff changeset	362 if (k != NULL) {
a61af66fc99e Initial load duke parents: diff changeset	363 // Make sure that resolving is legal
a61af66fc99e Initial load duke parents: diff changeset	364 EXCEPTION_MARK;
a61af66fc99e Initial load duke parents: diff changeset	365 KlassHandle klass(THREAD, k);
a61af66fc99e Initial load duke parents: diff changeset	366 // return NULL if verification fails
a61af66fc99e Initial load duke parents: diff changeset	367 verify_constant_pool_resolve(this_oop, klass, THREAD);
a61af66fc99e Initial load duke parents: diff changeset	368 if (HAS_PENDING_EXCEPTION) {
a61af66fc99e Initial load duke parents: diff changeset	369 CLEAR_PENDING_EXCEPTION;
a61af66fc99e Initial load duke parents: diff changeset	370 return NULL;
a61af66fc99e Initial load duke parents: diff changeset	371 }
a61af66fc99e Initial load duke parents: diff changeset	372 return klass();
a61af66fc99e Initial load duke parents: diff changeset	373 } else {
a61af66fc99e Initial load duke parents: diff changeset	374 return k;
a61af66fc99e Initial load duke parents: diff changeset	375 }
a61af66fc99e Initial load duke parents: diff changeset	376 }
a61af66fc99e Initial load duke parents: diff changeset	377 }
a61af66fc99e Initial load duke parents: diff changeset	378
a61af66fc99e Initial load duke parents: diff changeset	379
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	380 Klass* ConstantPool::klass_ref_at_if_loaded(constantPoolHandle this_oop, int which) {
0 a61af66fc99e Initial load duke parents: diff changeset	381 return klass_at_if_loaded(this_oop, this_oop->klass_ref_index_at(which));
a61af66fc99e Initial load duke parents: diff changeset	382 }
a61af66fc99e Initial load duke parents: diff changeset	383
a61af66fc99e Initial load duke parents: diff changeset	384
a61af66fc99e Initial load duke parents: diff changeset	385 // This is an interface for the compiler that allows accessing non-resolved entries
a61af66fc99e Initial load duke parents: diff changeset	386 // in the constant pool - but still performs the validations tests. Must be used
a61af66fc99e Initial load duke parents: diff changeset	387 // in a pre-parse of the compiler - to determine what it can do and not do.
a61af66fc99e Initial load duke parents: diff changeset	388 // Note: We cannot update the ConstantPool from the vm_thread.
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	389 Klass* ConstantPool::klass_ref_at_if_loaded_check(constantPoolHandle this_oop, int index, TRAPS) {
0 a61af66fc99e Initial load duke parents: diff changeset	390 int which = this_oop->klass_ref_index_at(index);
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	391 CPSlot entry = this_oop->slot_at(which);
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	392 if (entry.is_resolved()) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	393 assert(entry.get_klass()->is_klass(), "must be");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	394 return entry.get_klass();
0 a61af66fc99e Initial load duke parents: diff changeset	395 } else {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	396 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	397 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	398 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	399 oop protection_domain = this_oop->pool_holder()->protection_domain();
0 a61af66fc99e Initial load duke parents: diff changeset	400 Handle h_loader(THREAD, loader);
a61af66fc99e Initial load duke parents: diff changeset	401 Handle h_prot (THREAD, protection_domain);
a61af66fc99e Initial load duke parents: diff changeset	402 KlassHandle k(THREAD, SystemDictionary::find(name, h_loader, h_prot, THREAD));
a61af66fc99e Initial load duke parents: diff changeset	403
a61af66fc99e Initial load duke parents: diff changeset	404 // Do access check for klasses
a61af66fc99e Initial load duke parents: diff changeset	405 if( k.not_null() ) verify_constant_pool_resolve(this_oop, k, CHECK_NULL);
a61af66fc99e Initial load duke parents: diff changeset	406 return k();
a61af66fc99e Initial load duke parents: diff changeset	407 }
a61af66fc99e Initial load duke parents: diff changeset	408 }
a61af66fc99e Initial load duke parents: diff changeset	409
a61af66fc99e Initial load duke parents: diff changeset	410
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	411 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	412 int which) {
4862 f457154eee8b 7140882: Don't return booleans from methods returning pointers brutisso parents: 3960 diff changeset	413 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	414 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	415 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	416 // 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	417 if (PrintMiscellaneous && (Verbose\|\|WizardMode)) {
6266 1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 4862 diff changeset	418 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	419 }
81d815b05abb 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 2460 diff changeset	420 return NULL;
81d815b05abb 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 2460 diff changeset	421 }
81d815b05abb 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 2460 diff changeset	422 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	423 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	424 }
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 4862 diff changeset	425
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 4862 diff changeset	426
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	427 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	428 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	429 int cache_index = decode_cpcache_index(which, true);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	430 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	431 return e->has_appendix();
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 4862 diff changeset	432 }
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 4862 diff changeset	433
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	434 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	435 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	436 int cache_index = decode_cpcache_index(which, true);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	437 ConstantPoolCacheEntry* e = cpool->cache()->entry_at(cache_index);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	438 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	439 }
81d815b05abb 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 2460 diff changeset	440
81d815b05abb 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 2460 diff changeset	441
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	442 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	443 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	444 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	445 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	446 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	447 }
f6b0eb4e44cf 7200949: JSR 292: rubybench/bench/time/bench_base64.rb fails with jruby.jar not on boot class path twisti parents: 6733 diff changeset	448
f6b0eb4e44cf 7200949: JSR 292: rubybench/bench/time/bench_base64.rb fails with jruby.jar not on boot class path twisti parents: 6733 diff changeset	449 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	450 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	451 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	452 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	453 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	454 }
f6b0eb4e44cf 7200949: JSR 292: rubybench/bench/time/bench_base64.rb fails with jruby.jar not on boot class path twisti parents: 6733 diff changeset	455
f6b0eb4e44cf 7200949: JSR 292: rubybench/bench/time/bench_base64.rb fails with jruby.jar not on boot class path twisti parents: 6733 diff changeset	456
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	457 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	458 int name_index = name_ref_index_at(impl_name_and_type_ref_index_at(which, uncached));
0 a61af66fc99e Initial load duke parents: diff changeset	459 return symbol_at(name_index);
a61af66fc99e Initial load duke parents: diff changeset	460 }
a61af66fc99e Initial load duke parents: diff changeset	461
a61af66fc99e Initial load duke parents: diff changeset	462
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	463 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	464 int signature_index = signature_ref_index_at(impl_name_and_type_ref_index_at(which, uncached));
0 a61af66fc99e Initial load duke parents: diff changeset	465 return symbol_at(signature_index);
a61af66fc99e Initial load duke parents: diff changeset	466 }
a61af66fc99e Initial load duke parents: diff changeset	467
a61af66fc99e Initial load duke parents: diff changeset	468
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	469 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	470 int i = which;
389049f3f393 6858164: invokedynamic code needs some cleanup (post-6655638) jrose parents: 773 diff changeset	471 if (!uncached && cache() != NULL) {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	472 if (ConstantPool::is_invokedynamic_index(which)) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	473 // Invokedynamic index is index into resolved_references
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	474 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	475 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	476 assert(tag_at(pool_index).is_name_and_type(), "");
083fde3b838e 6964498: JSR 292 invokedynamic sites need local bootstrap methods jrose parents: 1602 diff changeset	477 return pool_index;
083fde3b838e 6964498: JSR 292 invokedynamic sites need local bootstrap methods jrose parents: 1602 diff changeset	478 }
1059 389049f3f393 6858164: invokedynamic code needs some cleanup (post-6655638) jrose parents: 773 diff changeset	479 // change byte-ordering and go via cache
389049f3f393 6858164: invokedynamic code needs some cleanup (post-6655638) jrose parents: 773 diff changeset	480 i = remap_instruction_operand_from_cache(which);
389049f3f393 6858164: invokedynamic code needs some cleanup (post-6655638) jrose parents: 773 diff changeset	481 } else {
1913 3b2dea75431e 6984311: JSR 292 needs optional bootstrap method parameters jrose parents: 1910 diff changeset	482 if (tag_at(which).is_invoke_dynamic()) {
3b2dea75431e 6984311: JSR 292 needs optional bootstrap method parameters jrose parents: 1910 diff changeset	483 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	484 assert(tag_at(pool_index).is_name_and_type(), "");
3b2dea75431e 6984311: JSR 292 needs optional bootstrap method parameters jrose parents: 1910 diff changeset	485 return pool_index;
3b2dea75431e 6984311: JSR 292 needs optional bootstrap method parameters jrose parents: 1910 diff changeset	486 }
1059 389049f3f393 6858164: invokedynamic code needs some cleanup (post-6655638) jrose parents: 773 diff changeset	487 }
389049f3f393 6858164: invokedynamic code needs some cleanup (post-6655638) jrose parents: 773 diff changeset	488 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	489 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	490 jint ref_index = *int_at_addr(i);
0 a61af66fc99e Initial load duke parents: diff changeset	491 return extract_high_short_from_int(ref_index);
a61af66fc99e Initial load duke parents: diff changeset	492 }
a61af66fc99e Initial load duke parents: diff changeset	493
a61af66fc99e Initial load duke parents: diff changeset	494
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	495 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	496 guarantee(!ConstantPool::is_invokedynamic_index(which),
1059 389049f3f393 6858164: invokedynamic code needs some cleanup (post-6655638) jrose parents: 773 diff changeset	497 "an invokedynamic instruction does not have a klass");
389049f3f393 6858164: invokedynamic code needs some cleanup (post-6655638) jrose parents: 773 diff changeset	498 int i = which;
389049f3f393 6858164: invokedynamic code needs some cleanup (post-6655638) jrose parents: 773 diff changeset	499 if (!uncached && cache() != NULL) {
389049f3f393 6858164: invokedynamic code needs some cleanup (post-6655638) jrose parents: 773 diff changeset	500 // change byte-ordering and go via cache
389049f3f393 6858164: invokedynamic code needs some cleanup (post-6655638) jrose parents: 773 diff changeset	501 i = remap_instruction_operand_from_cache(which);
389049f3f393 6858164: invokedynamic code needs some cleanup (post-6655638) jrose parents: 773 diff changeset	502 }
389049f3f393 6858164: invokedynamic code needs some cleanup (post-6655638) jrose parents: 773 diff changeset	503 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	504 jint ref_index = *int_at_addr(i);
0 a61af66fc99e Initial load duke parents: diff changeset	505 return extract_low_short_from_int(ref_index);
a61af66fc99e Initial load duke parents: diff changeset	506 }
a61af66fc99e Initial load duke parents: diff changeset	507
a61af66fc99e Initial load duke parents: diff changeset	508
726 be93aad57795 6655646: dynamic languages need dynamically linked call sites jrose parents: 579 diff changeset	509
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	510 int ConstantPool::remap_instruction_operand_from_cache(int operand) {
1565 ab102d5d923e 6939207: refactor constant pool index processing jrose parents: 1142 diff changeset	511 int cpc_index = operand;
ab102d5d923e 6939207: refactor constant pool index processing jrose parents: 1142 diff changeset	512 DEBUG_ONLY(cpc_index -= CPCACHE_INDEX_TAG);
ab102d5d923e 6939207: refactor constant pool index processing jrose parents: 1142 diff changeset	513 assert((int)(u2)cpc_index == cpc_index, "clean u2");
1059 389049f3f393 6858164: invokedynamic code needs some cleanup (post-6655638) jrose parents: 773 diff changeset	514 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	515 return member_index;
726 be93aad57795 6655646: dynamic languages need dynamically linked call sites jrose parents: 579 diff changeset	516 }
be93aad57795 6655646: dynamic languages need dynamically linked call sites jrose parents: 579 diff changeset	517
be93aad57795 6655646: dynamic languages need dynamically linked call sites jrose parents: 579 diff changeset	518
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	519 void ConstantPool::verify_constant_pool_resolve(constantPoolHandle this_oop, KlassHandle k, TRAPS) {
0 a61af66fc99e Initial load duke parents: diff changeset	520 if (k->oop_is_instance() \|\| k->oop_is_objArray()) {
a61af66fc99e Initial load duke parents: diff changeset	521 instanceKlassHandle holder (THREAD, this_oop->pool_holder());
6831 d8ce2825b193 8000213: NPG: Should have renamed arrayKlass and typeArrayKlass coleenp parents: 6733 diff changeset	522 Klass* elem_oop = k->oop_is_instance() ? k() : ObjArrayKlass::cast(k())->bottom_klass();
0 a61af66fc99e Initial load duke parents: diff changeset	523 KlassHandle element (THREAD, elem_oop);
a61af66fc99e Initial load duke parents: diff changeset	524
a61af66fc99e Initial load duke parents: diff changeset	525 // The element type could be a typeArray - we only need the access check if it is
a61af66fc99e Initial load duke parents: diff changeset	526 // an reference to another class
a61af66fc99e Initial load duke parents: diff changeset	527 if (element->oop_is_instance()) {
a61af66fc99e Initial load duke parents: diff changeset	528 LinkResolver::check_klass_accessability(holder, element, CHECK);
a61af66fc99e Initial load duke parents: diff changeset	529 }
a61af66fc99e Initial load duke parents: diff changeset	530 }
a61af66fc99e Initial load duke parents: diff changeset	531 }
a61af66fc99e Initial load duke parents: diff changeset	532
a61af66fc99e Initial load duke parents: diff changeset	533
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	534 int ConstantPool::name_ref_index_at(int which_nt) {
726 be93aad57795 6655646: dynamic languages need dynamically linked call sites jrose parents: 579 diff changeset	535 jint ref_index = name_and_type_at(which_nt);
0 a61af66fc99e Initial load duke parents: diff changeset	536 return extract_low_short_from_int(ref_index);
a61af66fc99e Initial load duke parents: diff changeset	537 }
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 int ConstantPool::signature_ref_index_at(int which_nt) {
726 be93aad57795 6655646: dynamic languages need dynamically linked call sites jrose parents: 579 diff changeset	541 jint ref_index = name_and_type_at(which_nt);
0 a61af66fc99e Initial load duke parents: diff changeset	542 return extract_high_short_from_int(ref_index);
a61af66fc99e Initial load duke parents: diff changeset	543 }
a61af66fc99e Initial load duke parents: diff changeset	544
a61af66fc99e Initial load duke parents: diff changeset	545
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	546 Klass* ConstantPool::klass_ref_at(int which, TRAPS) {
0 a61af66fc99e Initial load duke parents: diff changeset	547 return klass_at(klass_ref_index_at(which), CHECK_NULL);
a61af66fc99e Initial load duke parents: diff changeset	548 }
a61af66fc99e Initial load duke parents: diff changeset	549
a61af66fc99e Initial load duke parents: diff changeset	550
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	551 Symbol* ConstantPool::klass_name_at(int which) {
0 a61af66fc99e Initial load duke parents: diff changeset	552 assert(tag_at(which).is_unresolved_klass() \|\| tag_at(which).is_klass(),
a61af66fc99e Initial load duke parents: diff changeset	553 "Corrupted constant pool");
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	554 // A resolved constantPool entry will contain a Klass, otherwise a Symbol.
0 a61af66fc99e Initial load duke parents: diff changeset	555 // 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	556 // tag is not updated atomicly.
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	557 CPSlot entry = slot_at(which);
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	558 if (entry.is_resolved()) {
0 a61af66fc99e Initial load duke parents: diff changeset	559 // Already resolved - return entry's name.
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	560 assert(entry.get_klass()->is_klass(), "must be");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	561 return entry.get_klass()->name();
0 a61af66fc99e Initial load duke parents: diff changeset	562 } else {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	563 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	564 return entry.get_symbol();
0 a61af66fc99e Initial load duke parents: diff changeset	565 }
a61af66fc99e Initial load duke parents: diff changeset	566 }
a61af66fc99e Initial load duke parents: diff changeset	567
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	568 Symbol* ConstantPool::klass_ref_at_noresolve(int which) {
0 a61af66fc99e Initial load duke parents: diff changeset	569 jint ref_index = klass_ref_index_at(which);
a61af66fc99e Initial load duke parents: diff changeset	570 return klass_at_noresolve(ref_index);
a61af66fc99e Initial load duke parents: diff changeset	571 }
a61af66fc99e Initial load duke parents: diff changeset	572
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	573 Symbol* ConstantPool::uncached_klass_ref_at_noresolve(int which) {
1602 136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	574 jint ref_index = uncached_klass_ref_index_at(which);
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	575 return klass_at_noresolve(ref_index);
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	576 }
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	577
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	578 char* ConstantPool::string_at_noresolve(int which) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	579 Symbol* s = unresolved_string_at(which);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	580 if (s == NULL) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	581 return (char*)"<pseudo-string>";
0 a61af66fc99e Initial load duke parents: diff changeset	582 } else {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	583 return unresolved_string_at(which)->as_C_string();
0 a61af66fc99e Initial load duke parents: diff changeset	584 }
a61af66fc99e Initial load duke parents: diff changeset	585 }
a61af66fc99e Initial load duke parents: diff changeset	586
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	587 BasicType ConstantPool::basic_type_for_signature_at(int which) {
0 a61af66fc99e Initial load duke parents: diff changeset	588 return FieldType::basic_type(symbol_at(which));
a61af66fc99e Initial load duke parents: diff changeset	589 }
a61af66fc99e Initial load duke parents: diff changeset	590
a61af66fc99e Initial load duke parents: diff changeset	591
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	592 void ConstantPool::resolve_string_constants_impl(constantPoolHandle this_oop, TRAPS) {
0 a61af66fc99e Initial load duke parents: diff changeset	593 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	594 if (this_oop->tag_at(index).is_string()) {
0 a61af66fc99e Initial load duke parents: diff changeset	595 this_oop->string_at(index, CHECK);
a61af66fc99e Initial load duke parents: diff changeset	596 }
a61af66fc99e Initial load duke parents: diff changeset	597 }
a61af66fc99e Initial load duke parents: diff changeset	598 }
a61af66fc99e Initial load duke parents: diff changeset	599
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	600 // 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	601 // 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	602 // 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	603 // bit is set.
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	604 bool ConstantPool::resolve_class_constants(TRAPS) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	605 constantPoolHandle cp(THREAD, this);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	606 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	607 if (tag_at(index).is_unresolved_klass() &&
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	608 klass_at_if_loaded(cp, index) == NULL) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	609 return false;
1913 3b2dea75431e 6984311: JSR 292 needs optional bootstrap method parameters jrose parents: 1910 diff changeset	610 }
6725 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 // set_preresolution(); or some bit for future use
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	613 return true;
1913 3b2dea75431e 6984311: JSR 292 needs optional bootstrap method parameters jrose parents: 1910 diff changeset	614 }
3b2dea75431e 6984311: JSR 292 needs optional bootstrap method parameters jrose parents: 1910 diff changeset	615
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	616 // 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	617 // 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	618 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	619 int tag, TRAPS) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	620 ResourceMark rm;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	621 Symbol* error = PENDING_EXCEPTION->klass()->name();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	622 MonitorLockerEx ml(this_oop->lock()); // lock cpool to change tag.
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	623
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	624 int error_tag = (tag == JVM_CONSTANT_MethodHandle) ?
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	625 JVM_CONSTANT_MethodHandleInError : JVM_CONSTANT_MethodTypeInError;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	626
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	627 if (!PENDING_EXCEPTION->
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	628 is_a(SystemDictionary::LinkageError_klass())) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	629 // 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	630 // 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	631 // 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	632 // 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	633
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	634 } 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	635 SystemDictionary::add_resolution_error(this_oop, which, error);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	636 this_oop->tag_at_put(which, error_tag);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	637 } else {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	638 // 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	639 error = SystemDictionary::find_resolution_error(this_oop, which);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	640 assert(error != NULL, "checking");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	641 CLEAR_PENDING_EXCEPTION;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	642 THROW_MSG(error, "");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	643 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	644 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	645
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	646
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	647 // 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	648 // 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	649 // 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	650 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	651 oop result_oop = NULL;
1913 3b2dea75431e 6984311: JSR 292 needs optional bootstrap method parameters jrose parents: 1910 diff changeset	652 Handle throw_exception;
3b2dea75431e 6984311: JSR 292 needs optional bootstrap method parameters jrose parents: 1910 diff changeset	653
3b2dea75431e 6984311: JSR 292 needs optional bootstrap method parameters jrose parents: 1910 diff changeset	654 if (cache_index == _possible_index_sentinel) {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	655 // 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	656 // 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	657 assert(index > 0, "valid index");
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	658 cache_index = this_oop->cp_to_object_index(index);
1913 3b2dea75431e 6984311: JSR 292 needs optional bootstrap method parameters jrose parents: 1910 diff changeset	659 }
3b2dea75431e 6984311: JSR 292 needs optional bootstrap method parameters jrose parents: 1910 diff changeset	660 assert(cache_index == _no_index_sentinel \|\| cache_index >= 0, "");
3b2dea75431e 6984311: JSR 292 needs optional bootstrap method parameters jrose parents: 1910 diff changeset	661 assert(index == _no_index_sentinel \|\| index >= 0, "");
3b2dea75431e 6984311: JSR 292 needs optional bootstrap method parameters jrose parents: 1910 diff changeset	662
1602 136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	663 if (cache_index >= 0) {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	664 result_oop = this_oop->resolved_references()->obj_at(cache_index);
1602 136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	665 if (result_oop != NULL) {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	666 return result_oop;
1913 3b2dea75431e 6984311: JSR 292 needs optional bootstrap method parameters jrose parents: 1910 diff changeset	667 // That was easy...
1602 136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	668 }
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	669 index = this_oop->object_to_cp_index(cache_index);
1602 136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	670 }
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	671
1913 3b2dea75431e 6984311: JSR 292 needs optional bootstrap method parameters jrose parents: 1910 diff changeset	672 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	673
1602 136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	674 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	675
1602 136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	676 switch (tag_value) {
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	677
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	678 case JVM_CONSTANT_UnresolvedClass:
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	679 case JVM_CONSTANT_UnresolvedClassInError:
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	680 case JVM_CONSTANT_Class:
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	681 {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	682 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	683 Klass* resolved = klass_at_impl(this_oop, index, CHECK_NULL);
1602 136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	684 // ldc wants the java mirror.
2376 c7f3d0b4570f 7017732: move static fields into Class to prepare for perm gen removal never parents: 2332 diff changeset	685 result_oop = resolved->java_mirror();
1602 136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	686 break;
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	687 }
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 case JVM_CONSTANT_String:
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	690 assert(cache_index != _no_index_sentinel, "should have been set");
1602 136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	691 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	692 result_oop = this_oop->pseudo_string_at(index, cache_index);
1602 136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	693 break;
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	694 }
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	695 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	696 break;
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	697
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	698 case JVM_CONSTANT_MethodHandleInError:
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	699 case JVM_CONSTANT_MethodTypeInError:
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	700 {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	701 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	702 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	703 ResourceMark rm;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	704 THROW_MSG_0(error, "");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	705 break;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	706 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	707
1602 136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	708 case JVM_CONSTANT_MethodHandle:
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	709 {
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	710 int ref_kind = this_oop->method_handle_ref_kind_at(index);
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	711 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	712 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	713 Symbol* signature = this_oop->method_handle_signature_ref_at(index);
1602 136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	714 if (PrintMiscellaneous)
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	715 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	716 ref_kind, index, this_oop->method_handle_index_at(index),
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	717 callee_index, name->as_C_string(), signature->as_C_string());
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	718 KlassHandle callee;
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	719 { 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	720 callee = KlassHandle(THREAD, k);
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	721 }
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	722 KlassHandle klass(THREAD, this_oop->pool_holder());
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	723 Handle value = SystemDictionary::link_method_handle_constant(klass, ref_kind,
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	724 callee, name, signature,
1913 3b2dea75431e 6984311: JSR 292 needs optional bootstrap method parameters jrose parents: 1910 diff changeset	725 THREAD);
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	726 result_oop = value();
1913 3b2dea75431e 6984311: JSR 292 needs optional bootstrap method parameters jrose parents: 1910 diff changeset	727 if (HAS_PENDING_EXCEPTION) {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	728 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	729 }
1602 136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	730 break;
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	731 }
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	732
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	733 case JVM_CONSTANT_MethodType:
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	734 {
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	735 Symbol* signature = this_oop->method_type_signature_at(index);
1602 136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	736 if (PrintMiscellaneous)
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	737 tty->print_cr("resolve JVM_CONSTANT_MethodType [%d/%d] %s",
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	738 index, this_oop->method_type_index_at(index),
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	739 signature->as_C_string());
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	740 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	741 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	742 result_oop = value();
1913 3b2dea75431e 6984311: JSR 292 needs optional bootstrap method parameters jrose parents: 1910 diff changeset	743 if (HAS_PENDING_EXCEPTION) {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	744 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	745 }
1602 136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	746 break;
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	747 }
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	748
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	749 case JVM_CONSTANT_Integer:
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	750 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	751 prim_value.i = this_oop->int_at(index);
3b2dea75431e 6984311: JSR 292 needs optional bootstrap method parameters jrose parents: 1910 diff changeset	752 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	753 break;
3b2dea75431e 6984311: JSR 292 needs optional bootstrap method parameters jrose parents: 1910 diff changeset	754
1602 136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	755 case JVM_CONSTANT_Float:
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	756 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	757 prim_value.f = this_oop->float_at(index);
3b2dea75431e 6984311: JSR 292 needs optional bootstrap method parameters jrose parents: 1910 diff changeset	758 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	759 break;
3b2dea75431e 6984311: JSR 292 needs optional bootstrap method parameters jrose parents: 1910 diff changeset	760
1602 136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	761 case JVM_CONSTANT_Long:
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	762 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	763 prim_value.j = this_oop->long_at(index);
3b2dea75431e 6984311: JSR 292 needs optional bootstrap method parameters jrose parents: 1910 diff changeset	764 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	765 break;
3b2dea75431e 6984311: JSR 292 needs optional bootstrap method parameters jrose parents: 1910 diff changeset	766
1602 136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	767 case JVM_CONSTANT_Double:
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	768 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	769 prim_value.d = this_oop->double_at(index);
3b2dea75431e 6984311: JSR 292 needs optional bootstrap method parameters jrose parents: 1910 diff changeset	770 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	771 break;
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	772
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	773 default:
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	774 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	775 this_oop(), index, cache_index, tag_value) );
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	776 assert(false, "unexpected constant tag");
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	777 break;
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	778 }
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	779
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	780 if (cache_index >= 0) {
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	781 // Cache the oop here also.
1913 3b2dea75431e 6984311: JSR 292 needs optional bootstrap method parameters jrose parents: 1910 diff changeset	782 Handle result_handle(THREAD, result_oop);
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	783 MonitorLockerEx ml(this_oop->lock()); // don't know if we really need this
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	784 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	785 // 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	786 // 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	787 // 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	788 // result is used by all threads, and all future queries.
3b2dea75431e 6984311: JSR 292 needs optional bootstrap method parameters jrose parents: 1910 diff changeset	789 // 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	790 if (result == NULL) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	791 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	792 return result_handle();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	793 } else {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	794 // 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	795 // result_handle() for MethodHandles.
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	796 return result;
1602 136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	797 }
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	798 } else {
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	799 return result_oop;
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	800 }
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	801 }
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	802
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	803 oop ConstantPool::uncached_string_at(int which, TRAPS) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	804 Symbol* sym = unresolved_string_at(which);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	805 oop str = StringTable::intern(sym, CHECK_(NULL));
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	806 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	807 return str;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	808 }
6266 1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 4862 diff changeset	809
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	810
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	811 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	812 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	813
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 4862 diff changeset	814 Handle bsm;
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 4862 diff changeset	815 int argc;
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 4862 diff changeset	816 {
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 4862 diff changeset	817 // 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	818 // 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	819 // 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	820 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	821 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	822 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	823 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	824 }
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 4862 diff changeset	825
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 4862 diff changeset	826 // Extract the optional static arguments.
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 4862 diff changeset	827 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	828 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	829
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 4862 diff changeset	830 bsm = Handle(THREAD, bsm_oop);
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 4862 diff changeset	831 }
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 4862 diff changeset	832
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 4862 diff changeset	833 objArrayHandle info;
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 4862 diff changeset	834 {
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 4862 diff changeset	835 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	836 info = objArrayHandle(THREAD, info_oop);
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 4862 diff changeset	837 }
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 4862 diff changeset	838
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 4862 diff changeset	839 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	840 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	841 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	842 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	843 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	844 }
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 4862 diff changeset	845
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 4862 diff changeset	846 return info();
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 4862 diff changeset	847 }
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 4862 diff changeset	848
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	849 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	850 // 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	851 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	852 if (str != NULL) return str;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	853
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	854 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	855 str = StringTable::intern(sym, CHECK_(NULL));
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	856 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	857 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	858 return str;
0 a61af66fc99e Initial load duke parents: diff changeset	859 }
a61af66fc99e Initial load duke parents: diff changeset	860
a61af66fc99e Initial load duke parents: diff changeset	861
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	862 bool ConstantPool::klass_name_at_matches(instanceKlassHandle k,
0 a61af66fc99e Initial load duke parents: diff changeset	863 int which) {
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	864 // 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	865 Symbol* cp_name = klass_name_at(which);
0 a61af66fc99e Initial load duke parents: diff changeset	866 return (cp_name == k->name());
a61af66fc99e Initial load duke parents: diff changeset	867 }
a61af66fc99e Initial load duke parents: diff changeset	868
a61af66fc99e Initial load duke parents: diff changeset	869
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	870 // 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	871 // 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	872 // have per-thread safepoints.
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	873 // 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	874 // 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	875 void ConstantPool::unreference_symbols() {
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	876 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	877 constantTag tag = tag_at(index);
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	878 if (tag.is_symbol()) {
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	879 symbol_at(index)->decrement_refcount();
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	880 }
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	881 }
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	882 }
0 a61af66fc99e Initial load duke parents: diff changeset	883
a61af66fc99e Initial load duke parents: diff changeset	884
a61af66fc99e Initial load duke parents: diff changeset	885 // Compare this constant pool's entry at index1 to the constant pool
a61af66fc99e Initial load duke parents: diff changeset	886 // cp2's entry at index2.
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	887 bool ConstantPool::compare_entry_to(int index1, constantPoolHandle cp2,
0 a61af66fc99e Initial load duke parents: diff changeset	888 int index2, TRAPS) {
a61af66fc99e Initial load duke parents: diff changeset	889
a61af66fc99e Initial load duke parents: diff changeset	890 jbyte t1 = tag_at(index1).value();
a61af66fc99e Initial load duke parents: diff changeset	891 jbyte t2 = cp2->tag_at(index2).value();
a61af66fc99e Initial load duke parents: diff changeset	892
a61af66fc99e Initial load duke parents: diff changeset	893
a61af66fc99e Initial load duke parents: diff changeset	894 // JVM_CONSTANT_UnresolvedClassInError is equal to JVM_CONSTANT_UnresolvedClass
a61af66fc99e Initial load duke parents: diff changeset	895 // when comparing
a61af66fc99e Initial load duke parents: diff changeset	896 if (t1 == JVM_CONSTANT_UnresolvedClassInError) {
a61af66fc99e Initial load duke parents: diff changeset	897 t1 = JVM_CONSTANT_UnresolvedClass;
a61af66fc99e Initial load duke parents: diff changeset	898 }
a61af66fc99e Initial load duke parents: diff changeset	899 if (t2 == JVM_CONSTANT_UnresolvedClassInError) {
a61af66fc99e Initial load duke parents: diff changeset	900 t2 = JVM_CONSTANT_UnresolvedClass;
a61af66fc99e Initial load duke parents: diff changeset	901 }
a61af66fc99e Initial load duke parents: diff changeset	902
a61af66fc99e Initial load duke parents: diff changeset	903 if (t1 != t2) {
a61af66fc99e Initial load duke parents: diff changeset	904 // Not the same entry type so there is nothing else to check. Note
a61af66fc99e Initial load duke parents: diff changeset	905 // 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	906 // class pairs as different.
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	907 // 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	908 // 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	909 // plays out in the context of ConstantPool* merging.
0 a61af66fc99e Initial load duke parents: diff changeset	910 return false;
a61af66fc99e Initial load duke parents: diff changeset	911 }
a61af66fc99e Initial load duke parents: diff changeset	912
a61af66fc99e Initial load duke parents: diff changeset	913 switch (t1) {
a61af66fc99e Initial load duke parents: diff changeset	914 case JVM_CONSTANT_Class:
a61af66fc99e Initial load duke parents: diff changeset	915 {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	916 Klass* k1 = klass_at(index1, CHECK_false);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	917 Klass* k2 = cp2->klass_at(index2, CHECK_false);
0 a61af66fc99e Initial load duke parents: diff changeset	918 if (k1 == k2) {
a61af66fc99e Initial load duke parents: diff changeset	919 return true;
a61af66fc99e Initial load duke parents: diff changeset	920 }
a61af66fc99e Initial load duke parents: diff changeset	921 } break;
a61af66fc99e Initial load duke parents: diff changeset	922
a61af66fc99e Initial load duke parents: diff changeset	923 case JVM_CONSTANT_ClassIndex:
a61af66fc99e Initial load duke parents: diff changeset	924 {
a61af66fc99e Initial load duke parents: diff changeset	925 int recur1 = klass_index_at(index1);
a61af66fc99e Initial load duke parents: diff changeset	926 int recur2 = cp2->klass_index_at(index2);
a61af66fc99e Initial load duke parents: diff changeset	927 bool match = compare_entry_to(recur1, cp2, recur2, CHECK_false);
a61af66fc99e Initial load duke parents: diff changeset	928 if (match) {
a61af66fc99e Initial load duke parents: diff changeset	929 return true;
a61af66fc99e Initial load duke parents: diff changeset	930 }
a61af66fc99e Initial load duke parents: diff changeset	931 } break;
a61af66fc99e Initial load duke parents: diff changeset	932
a61af66fc99e Initial load duke parents: diff changeset	933 case JVM_CONSTANT_Double:
a61af66fc99e Initial load duke parents: diff changeset	934 {
a61af66fc99e Initial load duke parents: diff changeset	935 jdouble d1 = double_at(index1);
a61af66fc99e Initial load duke parents: diff changeset	936 jdouble d2 = cp2->double_at(index2);
a61af66fc99e Initial load duke parents: diff changeset	937 if (d1 == d2) {
a61af66fc99e Initial load duke parents: diff changeset	938 return true;
a61af66fc99e Initial load duke parents: diff changeset	939 }
a61af66fc99e Initial load duke parents: diff changeset	940 } break;
a61af66fc99e Initial load duke parents: diff changeset	941
a61af66fc99e Initial load duke parents: diff changeset	942 case JVM_CONSTANT_Fieldref:
a61af66fc99e Initial load duke parents: diff changeset	943 case JVM_CONSTANT_InterfaceMethodref:
a61af66fc99e Initial load duke parents: diff changeset	944 case JVM_CONSTANT_Methodref:
a61af66fc99e Initial load duke parents: diff changeset	945 {
a61af66fc99e Initial load duke parents: diff changeset	946 int recur1 = uncached_klass_ref_index_at(index1);
a61af66fc99e Initial load duke parents: diff changeset	947 int recur2 = cp2->uncached_klass_ref_index_at(index2);
a61af66fc99e Initial load duke parents: diff changeset	948 bool match = compare_entry_to(recur1, cp2, recur2, CHECK_false);
a61af66fc99e Initial load duke parents: diff changeset	949 if (match) {
a61af66fc99e Initial load duke parents: diff changeset	950 recur1 = uncached_name_and_type_ref_index_at(index1);
a61af66fc99e Initial load duke parents: diff changeset	951 recur2 = cp2->uncached_name_and_type_ref_index_at(index2);
a61af66fc99e Initial load duke parents: diff changeset	952 match = compare_entry_to(recur1, cp2, recur2, CHECK_false);
a61af66fc99e Initial load duke parents: diff changeset	953 if (match) {
a61af66fc99e Initial load duke parents: diff changeset	954 return true;
a61af66fc99e Initial load duke parents: diff changeset	955 }
a61af66fc99e Initial load duke parents: diff changeset	956 }
a61af66fc99e Initial load duke parents: diff changeset	957 } break;
a61af66fc99e Initial load duke parents: diff changeset	958
a61af66fc99e Initial load duke parents: diff changeset	959 case JVM_CONSTANT_Float:
a61af66fc99e Initial load duke parents: diff changeset	960 {
a61af66fc99e Initial load duke parents: diff changeset	961 jfloat f1 = float_at(index1);
a61af66fc99e Initial load duke parents: diff changeset	962 jfloat f2 = cp2->float_at(index2);
a61af66fc99e Initial load duke parents: diff changeset	963 if (f1 == f2) {
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_Integer:
a61af66fc99e Initial load duke parents: diff changeset	969 {
a61af66fc99e Initial load duke parents: diff changeset	970 jint i1 = int_at(index1);
a61af66fc99e Initial load duke parents: diff changeset	971 jint i2 = cp2->int_at(index2);
a61af66fc99e Initial load duke parents: diff changeset	972 if (i1 == i2) {
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
a61af66fc99e Initial load duke parents: diff changeset	977 case JVM_CONSTANT_Long:
a61af66fc99e Initial load duke parents: diff changeset	978 {
a61af66fc99e Initial load duke parents: diff changeset	979 jlong l1 = long_at(index1);
a61af66fc99e Initial load duke parents: diff changeset	980 jlong l2 = cp2->long_at(index2);
a61af66fc99e Initial load duke parents: diff changeset	981 if (l1 == l2) {
a61af66fc99e Initial load duke parents: diff changeset	982 return true;
a61af66fc99e Initial load duke parents: diff changeset	983 }
a61af66fc99e Initial load duke parents: diff changeset	984 } break;
a61af66fc99e Initial load duke parents: diff changeset	985
a61af66fc99e Initial load duke parents: diff changeset	986 case JVM_CONSTANT_NameAndType:
a61af66fc99e Initial load duke parents: diff changeset	987 {
a61af66fc99e Initial load duke parents: diff changeset	988 int recur1 = name_ref_index_at(index1);
a61af66fc99e Initial load duke parents: diff changeset	989 int recur2 = cp2->name_ref_index_at(index2);
a61af66fc99e Initial load duke parents: diff changeset	990 bool match = compare_entry_to(recur1, cp2, recur2, CHECK_false);
a61af66fc99e Initial load duke parents: diff changeset	991 if (match) {
a61af66fc99e Initial load duke parents: diff changeset	992 recur1 = signature_ref_index_at(index1);
a61af66fc99e Initial load duke parents: diff changeset	993 recur2 = cp2->signature_ref_index_at(index2);
a61af66fc99e Initial load duke parents: diff changeset	994 match = compare_entry_to(recur1, cp2, recur2, CHECK_false);
a61af66fc99e Initial load duke parents: diff changeset	995 if (match) {
a61af66fc99e Initial load duke parents: diff changeset	996 return true;
a61af66fc99e Initial load duke parents: diff changeset	997 }
a61af66fc99e Initial load duke parents: diff changeset	998 }
a61af66fc99e Initial load duke parents: diff changeset	999 } break;
a61af66fc99e Initial load duke parents: diff changeset	1000
a61af66fc99e Initial load duke parents: diff changeset	1001 case JVM_CONSTANT_StringIndex:
a61af66fc99e Initial load duke parents: diff changeset	1002 {
a61af66fc99e Initial load duke parents: diff changeset	1003 int recur1 = string_index_at(index1);
a61af66fc99e Initial load duke parents: diff changeset	1004 int recur2 = cp2->string_index_at(index2);
a61af66fc99e Initial load duke parents: diff changeset	1005 bool match = compare_entry_to(recur1, cp2, recur2, CHECK_false);
a61af66fc99e Initial load duke parents: diff changeset	1006 if (match) {
a61af66fc99e Initial load duke parents: diff changeset	1007 return true;
a61af66fc99e Initial load duke parents: diff changeset	1008 }
a61af66fc99e Initial load duke parents: diff changeset	1009 } break;
a61af66fc99e Initial load duke parents: diff changeset	1010
a61af66fc99e Initial load duke parents: diff changeset	1011 case JVM_CONSTANT_UnresolvedClass:
a61af66fc99e Initial load duke parents: diff changeset	1012 {
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	1013 Symbol* k1 = unresolved_klass_at(index1);
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	1014 Symbol* k2 = cp2->unresolved_klass_at(index2);
0 a61af66fc99e Initial load duke parents: diff changeset	1015 if (k1 == k2) {
a61af66fc99e Initial load duke parents: diff changeset	1016 return true;
a61af66fc99e Initial load duke parents: diff changeset	1017 }
a61af66fc99e Initial load duke parents: diff changeset	1018 } break;
a61af66fc99e Initial load duke parents: diff changeset	1019
1602 136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	1020 case JVM_CONSTANT_MethodType:
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	1021 {
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	1022 int k1 = method_type_index_at(index1);
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	1023 int k2 = cp2->method_type_index_at(index2);
2011 dad31fc330cd 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute jrose parents: 1972 diff changeset	1024 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	1025 if (match) {
1602 136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	1026 return true;
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	1027 }
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	1028 } break;
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	1029
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	1030 case JVM_CONSTANT_MethodHandle:
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	1031 {
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	1032 int k1 = method_handle_ref_kind_at(index1);
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	1033 int k2 = cp2->method_handle_ref_kind_at(index2);
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	1034 if (k1 == k2) {
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	1035 int i1 = method_handle_index_at(index1);
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	1036 int i2 = cp2->method_handle_index_at(index2);
2011 dad31fc330cd 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute jrose parents: 1972 diff changeset	1037 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	1038 if (match) {
1602 136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	1039 return true;
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	1040 }
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	1041 }
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	1042 } break;
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	1043
1660 083fde3b838e 6964498: JSR 292 invokedynamic sites need local bootstrap methods jrose parents: 1602 diff changeset	1044 case JVM_CONSTANT_InvokeDynamic:
083fde3b838e 6964498: JSR 292 invokedynamic sites need local bootstrap methods jrose parents: 1602 diff changeset	1045 {
2011 dad31fc330cd 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute jrose parents: 1972 diff changeset	1046 int k1 = invoke_dynamic_bootstrap_method_ref_index_at(index1);
dad31fc330cd 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute jrose parents: 1972 diff changeset	1047 int k2 = cp2->invoke_dynamic_bootstrap_method_ref_index_at(index2);
dad31fc330cd 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute jrose parents: 1972 diff changeset	1048 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	1049 if (!match) return false;
dad31fc330cd 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute jrose parents: 1972 diff changeset	1050 k1 = invoke_dynamic_name_and_type_ref_index_at(index1);
dad31fc330cd 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute jrose parents: 1972 diff changeset	1051 k2 = cp2->invoke_dynamic_name_and_type_ref_index_at(index2);
dad31fc330cd 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute jrose parents: 1972 diff changeset	1052 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	1053 if (!match) return false;
dad31fc330cd 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute jrose parents: 1972 diff changeset	1054 int argc = invoke_dynamic_argument_count_at(index1);
dad31fc330cd 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute jrose parents: 1972 diff changeset	1055 if (argc == cp2->invoke_dynamic_argument_count_at(index2)) {
dad31fc330cd 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute jrose parents: 1972 diff changeset	1056 for (int j = 0; j < argc; j++) {
dad31fc330cd 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute jrose parents: 1972 diff changeset	1057 k1 = invoke_dynamic_argument_index_at(index1, j);
dad31fc330cd 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute jrose parents: 1972 diff changeset	1058 k2 = cp2->invoke_dynamic_argument_index_at(index2, j);
dad31fc330cd 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute jrose parents: 1972 diff changeset	1059 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	1060 if (!match) return false;
1913 3b2dea75431e 6984311: JSR 292 needs optional bootstrap method parameters jrose parents: 1910 diff changeset	1061 }
2011 dad31fc330cd 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute jrose parents: 1972 diff changeset	1062 return true; // got through loop; all elements equal
1660 083fde3b838e 6964498: JSR 292 invokedynamic sites need local bootstrap methods jrose parents: 1602 diff changeset	1063 }
083fde3b838e 6964498: JSR 292 invokedynamic sites need local bootstrap methods jrose parents: 1602 diff changeset	1064 } break;
083fde3b838e 6964498: JSR 292 invokedynamic sites need local bootstrap methods jrose parents: 1602 diff changeset	1065
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1066 case JVM_CONSTANT_String:
0 a61af66fc99e Initial load duke parents: diff changeset	1067 {
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	1068 Symbol* s1 = unresolved_string_at(index1);
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	1069 Symbol* s2 = cp2->unresolved_string_at(index2);
0 a61af66fc99e Initial load duke parents: diff changeset	1070 if (s1 == s2) {
a61af66fc99e Initial load duke parents: diff changeset	1071 return true;
a61af66fc99e Initial load duke parents: diff changeset	1072 }
a61af66fc99e Initial load duke parents: diff changeset	1073 } break;
a61af66fc99e Initial load duke parents: diff changeset	1074
a61af66fc99e Initial load duke parents: diff changeset	1075 case JVM_CONSTANT_Utf8:
a61af66fc99e Initial load duke parents: diff changeset	1076 {
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	1077 Symbol* s1 = symbol_at(index1);
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	1078 Symbol* s2 = cp2->symbol_at(index2);
0 a61af66fc99e Initial load duke parents: diff changeset	1079 if (s1 == s2) {
a61af66fc99e Initial load duke parents: diff changeset	1080 return true;
a61af66fc99e Initial load duke parents: diff changeset	1081 }
a61af66fc99e Initial load duke parents: diff changeset	1082 } break;
a61af66fc99e Initial load duke parents: diff changeset	1083
a61af66fc99e Initial load duke parents: diff changeset	1084 // Invalid is used as the tag for the second constant pool entry
a61af66fc99e Initial load duke parents: diff changeset	1085 // occupied by JVM_CONSTANT_Double or JVM_CONSTANT_Long. It should
a61af66fc99e Initial load duke parents: diff changeset	1086 // not be seen by itself.
a61af66fc99e Initial load duke parents: diff changeset	1087 case JVM_CONSTANT_Invalid: // fall through
a61af66fc99e Initial load duke parents: diff changeset	1088
a61af66fc99e Initial load duke parents: diff changeset	1089 default:
a61af66fc99e Initial load duke parents: diff changeset	1090 ShouldNotReachHere();
a61af66fc99e Initial load duke parents: diff changeset	1091 break;
a61af66fc99e Initial load duke parents: diff changeset	1092 }
a61af66fc99e Initial load duke parents: diff changeset	1093
a61af66fc99e Initial load duke parents: diff changeset	1094 return false;
a61af66fc99e Initial load duke parents: diff changeset	1095 } // end compare_entry_to()
a61af66fc99e Initial load duke parents: diff changeset	1096
a61af66fc99e Initial load duke parents: diff changeset	1097
7952 edd76a5856f7 8005128: JSR 292: the mlvm redefineClassInBootstrap test crashes in ConstantPool::compare_entry_to sspitsyn parents: 7949 diff changeset	1098 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	1099 constantPoolHandle to_cp,
edd76a5856f7 8005128: JSR 292: the mlvm redefineClassInBootstrap test crashes in ConstantPool::compare_entry_to sspitsyn parents: 7949 diff changeset	1100 TRAPS) {
2011 dad31fc330cd 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute jrose parents: 1972 diff changeset	1101
dad31fc330cd 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute jrose parents: 1972 diff changeset	1102 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	1103 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	1104 if (from_oplen != 0) {
6934 4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6840 diff changeset	1105 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	1106 // 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	1107 if (old_oplen == 0) {
6934 4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6840 diff changeset	1108 // 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	1109 int len = from_cp->operands()->length();
4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6840 diff changeset	1110 Array<u2>* new_ops = MetadataFactory::new_array<u2>(loader_data, len, CHECK);
4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6840 diff changeset	1111 Copy::conjoint_memory_atomic(
4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6840 diff changeset	1112 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	1113 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	1114 } else {
dad31fc330cd 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute jrose parents: 1972 diff changeset	1115 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	1116 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	1117 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	1118 int from_off = from_oplen * sizeof(u2);
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1119 // Use the metaspace for the destination constant pool
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1120 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	1121 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	1122 // first part of dest
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1123 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	1124 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	1125 (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	1126 fillp += len;
dad31fc330cd 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute jrose parents: 1972 diff changeset	1127 // first part of src
7964 dc31f560d6e7 8006546: JSR 292: typos in the ConstantPool::copy_cp_impl() sspitsyn parents: 7957 diff changeset	1128 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	1129 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	1130 (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	1131 fillp += len;
dad31fc330cd 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute jrose parents: 1972 diff changeset	1132 // second part of dest
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1133 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	1134 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	1135 (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	1136 fillp += len;
dad31fc330cd 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute jrose parents: 1972 diff changeset	1137 // second part of src
7964 dc31f560d6e7 8006546: JSR 292: typos in the ConstantPool::copy_cp_impl() sspitsyn parents: 7957 diff changeset	1138 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	1139 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	1140 (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	1141 fillp += len;
dad31fc330cd 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute jrose parents: 1972 diff changeset	1142 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	1143
dad31fc330cd 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute jrose parents: 1972 diff changeset	1144 // 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	1145 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	1146 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	1147 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	1148 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	1149 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	1150 }
dad31fc330cd 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute jrose parents: 1972 diff changeset	1151
dad31fc330cd 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute jrose parents: 1972 diff changeset	1152 // replace target operands array with combined array
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1153 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	1154 }
dad31fc330cd 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute jrose parents: 1972 diff changeset	1155 }
7952 edd76a5856f7 8005128: JSR 292: the mlvm redefineClassInBootstrap test crashes in ConstantPool::compare_entry_to sspitsyn parents: 7949 diff changeset	1156 } // 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	1157
7952 edd76a5856f7 8005128: JSR 292: the mlvm redefineClassInBootstrap test crashes in ConstantPool::compare_entry_to sspitsyn parents: 7949 diff changeset	1158
edd76a5856f7 8005128: JSR 292: the mlvm redefineClassInBootstrap test crashes in ConstantPool::compare_entry_to sspitsyn parents: 7949 diff changeset	1159 // 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	1160 // 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	1161 // (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	1162 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	1163 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	1164
edd76a5856f7 8005128: JSR 292: the mlvm redefineClassInBootstrap test crashes in ConstantPool::compare_entry_to sspitsyn parents: 7949 diff changeset	1165
edd76a5856f7 8005128: JSR 292: the mlvm redefineClassInBootstrap test crashes in ConstantPool::compare_entry_to sspitsyn parents: 7949 diff changeset	1166 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	1167
edd76a5856f7 8005128: JSR 292: the mlvm redefineClassInBootstrap test crashes in ConstantPool::compare_entry_to sspitsyn parents: 7949 diff changeset	1168 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	1169 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	1170
edd76a5856f7 8005128: JSR 292: the mlvm redefineClassInBootstrap test crashes in ConstantPool::compare_entry_to sspitsyn parents: 7949 diff changeset	1171 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	1172 case JVM_CONSTANT_Double:
edd76a5856f7 8005128: JSR 292: the mlvm redefineClassInBootstrap test crashes in ConstantPool::compare_entry_to sspitsyn parents: 7949 diff changeset	1173 case JVM_CONSTANT_Long:
edd76a5856f7 8005128: JSR 292: the mlvm redefineClassInBootstrap test crashes in ConstantPool::compare_entry_to sspitsyn parents: 7949 diff changeset	1174 // 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	1175 src_i += 2;
edd76a5856f7 8005128: JSR 292: the mlvm redefineClassInBootstrap test crashes in ConstantPool::compare_entry_to sspitsyn parents: 7949 diff changeset	1176 dest_i += 2;
edd76a5856f7 8005128: JSR 292: the mlvm redefineClassInBootstrap test crashes in ConstantPool::compare_entry_to sspitsyn parents: 7949 diff changeset	1177 break;
edd76a5856f7 8005128: JSR 292: the mlvm redefineClassInBootstrap test crashes in ConstantPool::compare_entry_to sspitsyn parents: 7949 diff changeset	1178
edd76a5856f7 8005128: JSR 292: the mlvm redefineClassInBootstrap test crashes in ConstantPool::compare_entry_to sspitsyn parents: 7949 diff changeset	1179 default:
edd76a5856f7 8005128: JSR 292: the mlvm redefineClassInBootstrap test crashes in ConstantPool::compare_entry_to sspitsyn parents: 7949 diff changeset	1180 // 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	1181 src_i++;
edd76a5856f7 8005128: JSR 292: the mlvm redefineClassInBootstrap test crashes in ConstantPool::compare_entry_to sspitsyn parents: 7949 diff changeset	1182 dest_i++;
edd76a5856f7 8005128: JSR 292: the mlvm redefineClassInBootstrap test crashes in ConstantPool::compare_entry_to sspitsyn parents: 7949 diff changeset	1183 break;
edd76a5856f7 8005128: JSR 292: the mlvm redefineClassInBootstrap test crashes in ConstantPool::compare_entry_to sspitsyn parents: 7949 diff changeset	1184 }
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 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	1187
edd76a5856f7 8005128: JSR 292: the mlvm redefineClassInBootstrap test crashes in ConstantPool::compare_entry_to sspitsyn parents: 7949 diff changeset	1188 } // end copy_cp_to_impl()
0 a61af66fc99e Initial load duke parents: diff changeset	1189
a61af66fc99e Initial load duke parents: diff changeset	1190
a61af66fc99e Initial load duke parents: diff changeset	1191 // Copy this constant pool's entry at from_i to the constant pool
a61af66fc99e Initial load duke parents: diff changeset	1192 // to_cp's entry at to_i.
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1193 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	1194 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	1195 TRAPS) {
0 a61af66fc99e Initial load duke parents: diff changeset	1196
2011 dad31fc330cd 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute jrose parents: 1972 diff changeset	1197 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	1198 switch (tag) {
0 a61af66fc99e Initial load duke parents: diff changeset	1199 case JVM_CONSTANT_Class:
a61af66fc99e Initial load duke parents: diff changeset	1200 {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1201 Klass* k = from_cp->klass_at(from_i, CHECK);
0 a61af66fc99e Initial load duke parents: diff changeset	1202 to_cp->klass_at_put(to_i, k);
a61af66fc99e Initial load duke parents: diff changeset	1203 } break;
a61af66fc99e Initial load duke parents: diff changeset	1204
a61af66fc99e Initial load duke parents: diff changeset	1205 case JVM_CONSTANT_ClassIndex:
a61af66fc99e Initial load duke parents: diff changeset	1206 {
2011 dad31fc330cd 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute jrose parents: 1972 diff changeset	1207 jint ki = from_cp->klass_index_at(from_i);
0 a61af66fc99e Initial load duke parents: diff changeset	1208 to_cp->klass_index_at_put(to_i, ki);
a61af66fc99e Initial load duke parents: diff changeset	1209 } break;
a61af66fc99e Initial load duke parents: diff changeset	1210
a61af66fc99e Initial load duke parents: diff changeset	1211 case JVM_CONSTANT_Double:
a61af66fc99e Initial load duke parents: diff changeset	1212 {
2011 dad31fc330cd 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute jrose parents: 1972 diff changeset	1213 jdouble d = from_cp->double_at(from_i);
0 a61af66fc99e Initial load duke parents: diff changeset	1214 to_cp->double_at_put(to_i, d);
a61af66fc99e Initial load duke parents: diff changeset	1215 // double takes two constant pool entries so init second entry's tag
a61af66fc99e Initial load duke parents: diff changeset	1216 to_cp->tag_at_put(to_i + 1, JVM_CONSTANT_Invalid);
a61af66fc99e Initial load duke parents: diff changeset	1217 } break;
a61af66fc99e Initial load duke parents: diff changeset	1218
a61af66fc99e Initial load duke parents: diff changeset	1219 case JVM_CONSTANT_Fieldref:
a61af66fc99e Initial load duke parents: diff changeset	1220 {
2011 dad31fc330cd 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute jrose parents: 1972 diff changeset	1221 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	1222 int name_and_type_index = from_cp->uncached_name_and_type_ref_index_at(from_i);
0 a61af66fc99e Initial load duke parents: diff changeset	1223 to_cp->field_at_put(to_i, class_index, name_and_type_index);
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_Float:
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 jfloat f = from_cp->float_at(from_i);
0 a61af66fc99e Initial load duke parents: diff changeset	1229 to_cp->float_at_put(to_i, f);
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_Integer:
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 jint i = from_cp->int_at(from_i);
0 a61af66fc99e Initial load duke parents: diff changeset	1235 to_cp->int_at_put(to_i, i);
a61af66fc99e Initial load duke parents: diff changeset	1236 } break;
a61af66fc99e Initial load duke parents: diff changeset	1237
a61af66fc99e Initial load duke parents: diff changeset	1238 case JVM_CONSTANT_InterfaceMethodref:
a61af66fc99e Initial load duke parents: diff changeset	1239 {
2011 dad31fc330cd 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute jrose parents: 1972 diff changeset	1240 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	1241 int name_and_type_index = from_cp->uncached_name_and_type_ref_index_at(from_i);
0 a61af66fc99e Initial load duke parents: diff changeset	1242 to_cp->interface_method_at_put(to_i, class_index, name_and_type_index);
a61af66fc99e Initial load duke parents: diff changeset	1243 } break;
a61af66fc99e Initial load duke parents: diff changeset	1244
a61af66fc99e Initial load duke parents: diff changeset	1245 case JVM_CONSTANT_Long:
a61af66fc99e Initial load duke parents: diff changeset	1246 {
2011 dad31fc330cd 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute jrose parents: 1972 diff changeset	1247 jlong l = from_cp->long_at(from_i);
0 a61af66fc99e Initial load duke parents: diff changeset	1248 to_cp->long_at_put(to_i, l);
a61af66fc99e Initial load duke parents: diff changeset	1249 // long takes two constant pool entries so init second entry's tag
a61af66fc99e Initial load duke parents: diff changeset	1250 to_cp->tag_at_put(to_i + 1, JVM_CONSTANT_Invalid);
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_Methodref:
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 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	1256 int name_and_type_index = from_cp->uncached_name_and_type_ref_index_at(from_i);
0 a61af66fc99e Initial load duke parents: diff changeset	1257 to_cp->method_at_put(to_i, class_index, name_and_type_index);
a61af66fc99e Initial load duke parents: diff changeset	1258 } break;
a61af66fc99e Initial load duke parents: diff changeset	1259
a61af66fc99e Initial load duke parents: diff changeset	1260 case JVM_CONSTANT_NameAndType:
a61af66fc99e Initial load duke parents: diff changeset	1261 {
2011 dad31fc330cd 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute jrose parents: 1972 diff changeset	1262 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	1263 int signature_ref_index = from_cp->signature_ref_index_at(from_i);
0 a61af66fc99e Initial load duke parents: diff changeset	1264 to_cp->name_and_type_at_put(to_i, name_ref_index, signature_ref_index);
a61af66fc99e Initial load duke parents: diff changeset	1265 } break;
a61af66fc99e Initial load duke parents: diff changeset	1266
a61af66fc99e Initial load duke parents: diff changeset	1267 case JVM_CONSTANT_StringIndex:
a61af66fc99e Initial load duke parents: diff changeset	1268 {
2011 dad31fc330cd 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute jrose parents: 1972 diff changeset	1269 jint si = from_cp->string_index_at(from_i);
0 a61af66fc99e Initial load duke parents: diff changeset	1270 to_cp->string_index_at_put(to_i, si);
a61af66fc99e Initial load duke parents: diff changeset	1271 } break;
a61af66fc99e Initial load duke parents: diff changeset	1272
a61af66fc99e Initial load duke parents: diff changeset	1273 case JVM_CONSTANT_UnresolvedClass:
a61af66fc99e Initial load duke parents: diff changeset	1274 {
2332 fbbeec6dad2d 6512830: Error: assert(tag_at(which).is_unresolved_klass(), "Corrupted constant pool") coleenp parents: 2177 diff changeset	1275 // 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	1276 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	1277 if (entry.is_resolved()) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1278 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	1279 // Already resolved
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1280 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	1281 } else {
fbbeec6dad2d 6512830: Error: assert(tag_at(which).is_unresolved_klass(), "Corrupted constant pool") coleenp parents: 2177 diff changeset	1282 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	1283 }
0 a61af66fc99e Initial load duke parents: diff changeset	1284 } break;
a61af66fc99e Initial load duke parents: diff changeset	1285
a61af66fc99e Initial load duke parents: diff changeset	1286 case JVM_CONSTANT_UnresolvedClassInError:
a61af66fc99e Initial load duke parents: diff changeset	1287 {
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	1288 Symbol* k = from_cp->unresolved_klass_at(from_i);
0 a61af66fc99e Initial load duke parents: diff changeset	1289 to_cp->unresolved_klass_at_put(to_i, k);
a61af66fc99e Initial load duke parents: diff changeset	1290 to_cp->tag_at_put(to_i, JVM_CONSTANT_UnresolvedClassInError);
a61af66fc99e Initial load duke parents: diff changeset	1291 } break;
a61af66fc99e Initial load duke parents: diff changeset	1292
a61af66fc99e Initial load duke parents: diff changeset	1293
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1294 case JVM_CONSTANT_String:
0 a61af66fc99e Initial load duke parents: diff changeset	1295 {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1296 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	1297 to_cp->unresolved_string_at_put(to_i, s);
0 a61af66fc99e Initial load duke parents: diff changeset	1298 } break;
a61af66fc99e Initial load duke parents: diff changeset	1299
a61af66fc99e Initial load duke parents: diff changeset	1300 case JVM_CONSTANT_Utf8:
a61af66fc99e Initial load duke parents: diff changeset	1301 {
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	1302 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	1303 // 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	1304 s->increment_refcount();
0 a61af66fc99e Initial load duke parents: diff changeset	1305 to_cp->symbol_at_put(to_i, s);
a61af66fc99e Initial load duke parents: diff changeset	1306 } break;
a61af66fc99e Initial load duke parents: diff changeset	1307
1602 136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	1308 case JVM_CONSTANT_MethodType:
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	1309 {
2011 dad31fc330cd 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute jrose parents: 1972 diff changeset	1310 jint k = from_cp->method_type_index_at(from_i);
1602 136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	1311 to_cp->method_type_index_at_put(to_i, k);
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	1312 } break;
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	1313
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	1314 case JVM_CONSTANT_MethodHandle:
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	1315 {
2011 dad31fc330cd 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute jrose parents: 1972 diff changeset	1316 int k1 = from_cp->method_handle_ref_kind_at(from_i);
dad31fc330cd 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute jrose parents: 1972 diff changeset	1317 int k2 = from_cp->method_handle_index_at(from_i);
1602 136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	1318 to_cp->method_handle_index_at_put(to_i, k1, k2);
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	1319 } break;
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	1320
1660 083fde3b838e 6964498: JSR 292 invokedynamic sites need local bootstrap methods jrose parents: 1602 diff changeset	1321 case JVM_CONSTANT_InvokeDynamic:
083fde3b838e 6964498: JSR 292 invokedynamic sites need local bootstrap methods jrose parents: 1602 diff changeset	1322 {
2011 dad31fc330cd 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute jrose parents: 1972 diff changeset	1323 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	1324 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	1325 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	1326 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	1327 } break;
083fde3b838e 6964498: JSR 292 invokedynamic sites need local bootstrap methods jrose parents: 1602 diff changeset	1328
0 a61af66fc99e Initial load duke parents: diff changeset	1329 // Invalid is used as the tag for the second constant pool entry
a61af66fc99e Initial load duke parents: diff changeset	1330 // occupied by JVM_CONSTANT_Double or JVM_CONSTANT_Long. It should
a61af66fc99e Initial load duke parents: diff changeset	1331 // not be seen by itself.
a61af66fc99e Initial load duke parents: diff changeset	1332 case JVM_CONSTANT_Invalid: // fall through
a61af66fc99e Initial load duke parents: diff changeset	1333
a61af66fc99e Initial load duke parents: diff changeset	1334 default:
a61af66fc99e Initial load duke parents: diff changeset	1335 {
a61af66fc99e Initial load duke parents: diff changeset	1336 ShouldNotReachHere();
a61af66fc99e Initial load duke parents: diff changeset	1337 } break;
a61af66fc99e Initial load duke parents: diff changeset	1338 }
a61af66fc99e Initial load duke parents: diff changeset	1339 } // end copy_entry_to()
a61af66fc99e Initial load duke parents: diff changeset	1340
a61af66fc99e Initial load duke parents: diff changeset	1341
a61af66fc99e Initial load duke parents: diff changeset	1342 // Search constant pool search_cp for an entry that matches this
a61af66fc99e Initial load duke parents: diff changeset	1343 // constant pool's entry at pattern_i. Returns the index of a
a61af66fc99e Initial load duke parents: diff changeset	1344 // 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	1345 int ConstantPool::find_matching_entry(int pattern_i,
0 a61af66fc99e Initial load duke parents: diff changeset	1346 constantPoolHandle search_cp, TRAPS) {
a61af66fc99e Initial load duke parents: diff changeset	1347
a61af66fc99e Initial load duke parents: diff changeset	1348 // index zero (0) is not used
a61af66fc99e Initial load duke parents: diff changeset	1349 for (int i = 1; i < search_cp->length(); i++) {
a61af66fc99e Initial load duke parents: diff changeset	1350 bool found = compare_entry_to(pattern_i, search_cp, i, CHECK_0);
a61af66fc99e Initial load duke parents: diff changeset	1351 if (found) {
a61af66fc99e Initial load duke parents: diff changeset	1352 return i;
a61af66fc99e Initial load duke parents: diff changeset	1353 }
a61af66fc99e Initial load duke parents: diff changeset	1354 }
a61af66fc99e Initial load duke parents: diff changeset	1355
a61af66fc99e Initial load duke parents: diff changeset	1356 return 0; // entry not found; return unused index zero (0)
a61af66fc99e Initial load duke parents: diff changeset	1357 } // end find_matching_entry()
a61af66fc99e Initial load duke parents: diff changeset	1358
a61af66fc99e Initial load duke parents: diff changeset	1359
a61af66fc99e Initial load duke parents: diff changeset	1360 #ifndef PRODUCT
a61af66fc99e Initial load duke parents: diff changeset	1361
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1362 const char* ConstantPool::printable_name_at(int which) {
0 a61af66fc99e Initial load duke parents: diff changeset	1363
a61af66fc99e Initial load duke parents: diff changeset	1364 constantTag tag = tag_at(which);
a61af66fc99e Initial load duke parents: diff changeset	1365
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1366 if (tag.is_string()) {
0 a61af66fc99e Initial load duke parents: diff changeset	1367 return string_at_noresolve(which);
a61af66fc99e Initial load duke parents: diff changeset	1368 } else if (tag.is_klass() \|\| tag.is_unresolved_klass()) {
a61af66fc99e Initial load duke parents: diff changeset	1369 return klass_name_at(which)->as_C_string();
a61af66fc99e Initial load duke parents: diff changeset	1370 } else if (tag.is_symbol()) {
a61af66fc99e Initial load duke parents: diff changeset	1371 return symbol_at(which)->as_C_string();
a61af66fc99e Initial load duke parents: diff changeset	1372 }
a61af66fc99e Initial load duke parents: diff changeset	1373 return "";
a61af66fc99e Initial load duke parents: diff changeset	1374 }
a61af66fc99e Initial load duke parents: diff changeset	1375
a61af66fc99e Initial load duke parents: diff changeset	1376 #endif // PRODUCT
a61af66fc99e Initial load duke parents: diff changeset	1377
a61af66fc99e Initial load duke parents: diff changeset	1378
a61af66fc99e Initial load duke parents: diff changeset	1379 // JVMTI GetConstantPool support
a61af66fc99e Initial load duke parents: diff changeset	1380
9060 cc32ccaaf47f 8003310: Enable -Wunused-function when compiling with gcc mikael parents: 8782 diff changeset	1381 // For debugging of constant pool
cc32ccaaf47f 8003310: Enable -Wunused-function when compiling with gcc mikael parents: 8782 diff changeset	1382 const bool debug_cpool = false;
0 a61af66fc99e Initial load duke parents: diff changeset	1383
9060 cc32ccaaf47f 8003310: Enable -Wunused-function when compiling with gcc mikael parents: 8782 diff changeset	1384 #define DBG(code) do { if (debug_cpool) { (code); } } while(0)
0 a61af66fc99e Initial load duke parents: diff changeset	1385
a61af66fc99e Initial load duke parents: diff changeset	1386 static void print_cpool_bytes(jint cnt, u1 *bytes) {
9060 cc32ccaaf47f 8003310: Enable -Wunused-function when compiling with gcc mikael parents: 8782 diff changeset	1387 const char* WARN_MSG = "Must not be such entry!";
0 a61af66fc99e Initial load duke parents: diff changeset	1388 jint size = 0;
a61af66fc99e Initial load duke parents: diff changeset	1389 u2 idx1, idx2;
a61af66fc99e Initial load duke parents: diff changeset	1390
a61af66fc99e Initial load duke parents: diff changeset	1391 for (jint idx = 1; idx < cnt; idx++) {
a61af66fc99e Initial load duke parents: diff changeset	1392 jint ent_size = 0;
a61af66fc99e Initial load duke parents: diff changeset	1393 u1 tag = *bytes++;
a61af66fc99e Initial load duke parents: diff changeset	1394 size++; // count tag
a61af66fc99e Initial load duke parents: diff changeset	1395
a61af66fc99e Initial load duke parents: diff changeset	1396 printf("const #%03d, tag: %02d ", idx, tag);
a61af66fc99e Initial load duke parents: diff changeset	1397 switch(tag) {
a61af66fc99e Initial load duke parents: diff changeset	1398 case JVM_CONSTANT_Invalid: {
a61af66fc99e Initial load duke parents: diff changeset	1399 printf("Invalid");
a61af66fc99e Initial load duke parents: diff changeset	1400 break;
a61af66fc99e Initial load duke parents: diff changeset	1401 }
a61af66fc99e Initial load duke parents: diff changeset	1402 case JVM_CONSTANT_Unicode: {
a61af66fc99e Initial load duke parents: diff changeset	1403 printf("Unicode %s", WARN_MSG);
a61af66fc99e Initial load duke parents: diff changeset	1404 break;
a61af66fc99e Initial load duke parents: diff changeset	1405 }
a61af66fc99e Initial load duke parents: diff changeset	1406 case JVM_CONSTANT_Utf8: {
a61af66fc99e Initial load duke parents: diff changeset	1407 u2 len = Bytes::get_Java_u2(bytes);
a61af66fc99e Initial load duke parents: diff changeset	1408 char str[128];
a61af66fc99e Initial load duke parents: diff changeset	1409 if (len > 127) {
a61af66fc99e Initial load duke parents: diff changeset	1410 len = 127;
a61af66fc99e Initial load duke parents: diff changeset	1411 }
a61af66fc99e Initial load duke parents: diff changeset	1412 strncpy(str, (char *) (bytes+2), len);
a61af66fc99e Initial load duke parents: diff changeset	1413 str[len] = '\0';
a61af66fc99e Initial load duke parents: diff changeset	1414 printf("Utf8 \"%s\"", str);
a61af66fc99e Initial load duke parents: diff changeset	1415 ent_size = 2 + len;
a61af66fc99e Initial load duke parents: diff changeset	1416 break;
a61af66fc99e Initial load duke parents: diff changeset	1417 }
a61af66fc99e Initial load duke parents: diff changeset	1418 case JVM_CONSTANT_Integer: {
a61af66fc99e Initial load duke parents: diff changeset	1419 u4 val = Bytes::get_Java_u4(bytes);
a61af66fc99e Initial load duke parents: diff changeset	1420 printf("int %d", (int ) &val);
a61af66fc99e Initial load duke parents: diff changeset	1421 ent_size = 4;
a61af66fc99e Initial load duke parents: diff changeset	1422 break;
a61af66fc99e Initial load duke parents: diff changeset	1423 }
a61af66fc99e Initial load duke parents: diff changeset	1424 case JVM_CONSTANT_Float: {
a61af66fc99e Initial load duke parents: diff changeset	1425 u4 val = Bytes::get_Java_u4(bytes);
a61af66fc99e Initial load duke parents: diff changeset	1426 printf("float %5.3ff", (float ) &val);
a61af66fc99e Initial load duke parents: diff changeset	1427 ent_size = 4;
a61af66fc99e Initial load duke parents: diff changeset	1428 break;
a61af66fc99e Initial load duke parents: diff changeset	1429 }
a61af66fc99e Initial load duke parents: diff changeset	1430 case JVM_CONSTANT_Long: {
a61af66fc99e Initial load duke parents: diff changeset	1431 u8 val = Bytes::get_Java_u8(bytes);
3960 f08d439fab8c 7089790: integrate bsd-port changes never parents: 3461 diff changeset	1432 printf("long "INT64_FORMAT, (int64_t) (jlong ) &val);
0 a61af66fc99e Initial load duke parents: diff changeset	1433 ent_size = 8;
a61af66fc99e Initial load duke parents: diff changeset	1434 idx++; // Long takes two cpool slots
a61af66fc99e Initial load duke parents: diff changeset	1435 break;
a61af66fc99e Initial load duke parents: diff changeset	1436 }
a61af66fc99e Initial load duke parents: diff changeset	1437 case JVM_CONSTANT_Double: {
a61af66fc99e Initial load duke parents: diff changeset	1438 u8 val = Bytes::get_Java_u8(bytes);
a61af66fc99e Initial load duke parents: diff changeset	1439 printf("double %5.3fd", (jdouble )&val);
a61af66fc99e Initial load duke parents: diff changeset	1440 ent_size = 8;
a61af66fc99e Initial load duke parents: diff changeset	1441 idx++; // Double takes two cpool slots
a61af66fc99e Initial load duke parents: diff changeset	1442 break;
a61af66fc99e Initial load duke parents: diff changeset	1443 }
a61af66fc99e Initial load duke parents: diff changeset	1444 case JVM_CONSTANT_Class: {
a61af66fc99e Initial load duke parents: diff changeset	1445 idx1 = Bytes::get_Java_u2(bytes);
a61af66fc99e Initial load duke parents: diff changeset	1446 printf("class #%03d", idx1);
a61af66fc99e Initial load duke parents: diff changeset	1447 ent_size = 2;
a61af66fc99e Initial load duke parents: diff changeset	1448 break;
a61af66fc99e Initial load duke parents: diff changeset	1449 }
a61af66fc99e Initial load duke parents: diff changeset	1450 case JVM_CONSTANT_String: {
a61af66fc99e Initial load duke parents: diff changeset	1451 idx1 = Bytes::get_Java_u2(bytes);
a61af66fc99e Initial load duke parents: diff changeset	1452 printf("String #%03d", idx1);
a61af66fc99e Initial load duke parents: diff changeset	1453 ent_size = 2;
a61af66fc99e Initial load duke parents: diff changeset	1454 break;
a61af66fc99e Initial load duke parents: diff changeset	1455 }
a61af66fc99e Initial load duke parents: diff changeset	1456 case JVM_CONSTANT_Fieldref: {
a61af66fc99e Initial load duke parents: diff changeset	1457 idx1 = Bytes::get_Java_u2(bytes);
a61af66fc99e Initial load duke parents: diff changeset	1458 idx2 = Bytes::get_Java_u2(bytes+2);
a61af66fc99e Initial load duke parents: diff changeset	1459 printf("Field #%03d, #%03d", (int) idx1, (int) idx2);
a61af66fc99e Initial load duke parents: diff changeset	1460 ent_size = 4;
a61af66fc99e Initial load duke parents: diff changeset	1461 break;
a61af66fc99e Initial load duke parents: diff changeset	1462 }
a61af66fc99e Initial load duke parents: diff changeset	1463 case JVM_CONSTANT_Methodref: {
a61af66fc99e Initial load duke parents: diff changeset	1464 idx1 = Bytes::get_Java_u2(bytes);
a61af66fc99e Initial load duke parents: diff changeset	1465 idx2 = Bytes::get_Java_u2(bytes+2);
a61af66fc99e Initial load duke parents: diff changeset	1466 printf("Method #%03d, #%03d", idx1, idx2);
a61af66fc99e Initial load duke parents: diff changeset	1467 ent_size = 4;
a61af66fc99e Initial load duke parents: diff changeset	1468 break;
a61af66fc99e Initial load duke parents: diff changeset	1469 }
a61af66fc99e Initial load duke parents: diff changeset	1470 case JVM_CONSTANT_InterfaceMethodref: {
a61af66fc99e Initial load duke parents: diff changeset	1471 idx1 = Bytes::get_Java_u2(bytes);
a61af66fc99e Initial load duke parents: diff changeset	1472 idx2 = Bytes::get_Java_u2(bytes+2);
a61af66fc99e Initial load duke parents: diff changeset	1473 printf("InterfMethod #%03d, #%03d", idx1, idx2);
a61af66fc99e Initial load duke parents: diff changeset	1474 ent_size = 4;
a61af66fc99e Initial load duke parents: diff changeset	1475 break;
a61af66fc99e Initial load duke parents: diff changeset	1476 }
a61af66fc99e Initial load duke parents: diff changeset	1477 case JVM_CONSTANT_NameAndType: {
a61af66fc99e Initial load duke parents: diff changeset	1478 idx1 = Bytes::get_Java_u2(bytes);
a61af66fc99e Initial load duke parents: diff changeset	1479 idx2 = Bytes::get_Java_u2(bytes+2);
a61af66fc99e Initial load duke parents: diff changeset	1480 printf("NameAndType #%03d, #%03d", idx1, idx2);
a61af66fc99e Initial load duke parents: diff changeset	1481 ent_size = 4;
a61af66fc99e Initial load duke parents: diff changeset	1482 break;
a61af66fc99e Initial load duke parents: diff changeset	1483 }
a61af66fc99e Initial load duke parents: diff changeset	1484 case JVM_CONSTANT_ClassIndex: {
a61af66fc99e Initial load duke parents: diff changeset	1485 printf("ClassIndex %s", WARN_MSG);
a61af66fc99e Initial load duke parents: diff changeset	1486 break;
a61af66fc99e Initial load duke parents: diff changeset	1487 }
a61af66fc99e Initial load duke parents: diff changeset	1488 case JVM_CONSTANT_UnresolvedClass: {
a61af66fc99e Initial load duke parents: diff changeset	1489 printf("UnresolvedClass: %s", WARN_MSG);
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_UnresolvedClassInError: {
a61af66fc99e Initial load duke parents: diff changeset	1493 printf("UnresolvedClassInErr: %s", WARN_MSG);
a61af66fc99e Initial load duke parents: diff changeset	1494 break;
a61af66fc99e Initial load duke parents: diff changeset	1495 }
a61af66fc99e Initial load duke parents: diff changeset	1496 case JVM_CONSTANT_StringIndex: {
a61af66fc99e Initial load duke parents: diff changeset	1497 printf("StringIndex: %s", WARN_MSG);
a61af66fc99e Initial load duke parents: diff changeset	1498 break;
a61af66fc99e Initial load duke parents: diff changeset	1499 }
a61af66fc99e Initial load duke parents: diff changeset	1500 }
a61af66fc99e Initial load duke parents: diff changeset	1501 printf(";\n");
a61af66fc99e Initial load duke parents: diff changeset	1502 bytes += ent_size;
a61af66fc99e Initial load duke parents: diff changeset	1503 size += ent_size;
a61af66fc99e Initial load duke parents: diff changeset	1504 }
a61af66fc99e Initial load duke parents: diff changeset	1505 printf("Cpool size: %d\n", size);
a61af66fc99e Initial load duke parents: diff changeset	1506 fflush(0);
a61af66fc99e Initial load duke parents: diff changeset	1507 return;
a61af66fc99e Initial load duke parents: diff changeset	1508 } /* end print_cpool_bytes */
a61af66fc99e Initial load duke parents: diff changeset	1509
a61af66fc99e Initial load duke parents: diff changeset	1510
a61af66fc99e Initial load duke parents: diff changeset	1511 // Returns size of constant pool entry.
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1512 jint ConstantPool::cpool_entry_size(jint idx) {
0 a61af66fc99e Initial load duke parents: diff changeset	1513 switch(tag_at(idx).value()) {
a61af66fc99e Initial load duke parents: diff changeset	1514 case JVM_CONSTANT_Invalid:
a61af66fc99e Initial load duke parents: diff changeset	1515 case JVM_CONSTANT_Unicode:
a61af66fc99e Initial load duke parents: diff changeset	1516 return 1;
a61af66fc99e Initial load duke parents: diff changeset	1517
a61af66fc99e Initial load duke parents: diff changeset	1518 case JVM_CONSTANT_Utf8:
a61af66fc99e Initial load duke parents: diff changeset	1519 return 3 + symbol_at(idx)->utf8_length();
a61af66fc99e Initial load duke parents: diff changeset	1520
a61af66fc99e Initial load duke parents: diff changeset	1521 case JVM_CONSTANT_Class:
a61af66fc99e Initial load duke parents: diff changeset	1522 case JVM_CONSTANT_String:
a61af66fc99e Initial load duke parents: diff changeset	1523 case JVM_CONSTANT_ClassIndex:
a61af66fc99e Initial load duke parents: diff changeset	1524 case JVM_CONSTANT_UnresolvedClass:
a61af66fc99e Initial load duke parents: diff changeset	1525 case JVM_CONSTANT_UnresolvedClassInError:
a61af66fc99e Initial load duke parents: diff changeset	1526 case JVM_CONSTANT_StringIndex:
1602 136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	1527 case JVM_CONSTANT_MethodType:
0 a61af66fc99e Initial load duke parents: diff changeset	1528 return 3;
a61af66fc99e Initial load duke parents: diff changeset	1529
1602 136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	1530 case JVM_CONSTANT_MethodHandle:
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	1531 return 4; //tag, ref_kind, ref_index
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	1532
0 a61af66fc99e Initial load duke parents: diff changeset	1533 case JVM_CONSTANT_Integer:
a61af66fc99e Initial load duke parents: diff changeset	1534 case JVM_CONSTANT_Float:
a61af66fc99e Initial load duke parents: diff changeset	1535 case JVM_CONSTANT_Fieldref:
a61af66fc99e Initial load duke parents: diff changeset	1536 case JVM_CONSTANT_Methodref:
a61af66fc99e Initial load duke parents: diff changeset	1537 case JVM_CONSTANT_InterfaceMethodref:
a61af66fc99e Initial load duke parents: diff changeset	1538 case JVM_CONSTANT_NameAndType:
1913 3b2dea75431e 6984311: JSR 292 needs optional bootstrap method parameters jrose parents: 1910 diff changeset	1539 return 5;
3b2dea75431e 6984311: JSR 292 needs optional bootstrap method parameters jrose parents: 1910 diff changeset	1540
1660 083fde3b838e 6964498: JSR 292 invokedynamic sites need local bootstrap methods jrose parents: 1602 diff changeset	1541 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	1542 // 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	1543 return 5;
0 a61af66fc99e Initial load duke parents: diff changeset	1544
a61af66fc99e Initial load duke parents: diff changeset	1545 case JVM_CONSTANT_Long:
a61af66fc99e Initial load duke parents: diff changeset	1546 case JVM_CONSTANT_Double:
a61af66fc99e Initial load duke parents: diff changeset	1547 return 9;
a61af66fc99e Initial load duke parents: diff changeset	1548 }
a61af66fc99e Initial load duke parents: diff changeset	1549 assert(false, "cpool_entry_size: Invalid constant pool entry tag");
a61af66fc99e Initial load duke parents: diff changeset	1550 return 1;
a61af66fc99e Initial load duke parents: diff changeset	1551 } /* end cpool_entry_size */
a61af66fc99e Initial load duke parents: diff changeset	1552
a61af66fc99e Initial load duke parents: diff changeset	1553
a61af66fc99e Initial load duke parents: diff changeset	1554 // SymbolHashMap is used to find a constant pool index from a string.
a61af66fc99e Initial load duke parents: diff changeset	1555 // This function fills in SymbolHashMaps, one for utf8s and one for
a61af66fc99e Initial load duke parents: diff changeset	1556 // 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	1557 jint ConstantPool::hash_entries_to(SymbolHashMap *symmap,
0 a61af66fc99e Initial load duke parents: diff changeset	1558 SymbolHashMap *classmap) {
a61af66fc99e Initial load duke parents: diff changeset	1559 jint size = 0;
a61af66fc99e Initial load duke parents: diff changeset	1560
a61af66fc99e Initial load duke parents: diff changeset	1561 for (u2 idx = 1; idx < length(); idx++) {
a61af66fc99e Initial load duke parents: diff changeset	1562 u2 tag = tag_at(idx).value();
a61af66fc99e Initial load duke parents: diff changeset	1563 size += cpool_entry_size(idx);
a61af66fc99e Initial load duke parents: diff changeset	1564
a61af66fc99e Initial load duke parents: diff changeset	1565 switch(tag) {
a61af66fc99e Initial load duke parents: diff changeset	1566 case JVM_CONSTANT_Utf8: {
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	1567 Symbol* sym = symbol_at(idx);
0 a61af66fc99e Initial load duke parents: diff changeset	1568 symmap->add_entry(sym, idx);
a61af66fc99e Initial load duke parents: diff changeset	1569 DBG(printf("adding symbol entry %s = %d\n", sym->as_utf8(), idx));
a61af66fc99e Initial load duke parents: diff changeset	1570 break;
a61af66fc99e Initial load duke parents: diff changeset	1571 }
a61af66fc99e Initial load duke parents: diff changeset	1572 case JVM_CONSTANT_Class:
a61af66fc99e Initial load duke parents: diff changeset	1573 case JVM_CONSTANT_UnresolvedClass:
a61af66fc99e Initial load duke parents: diff changeset	1574 case JVM_CONSTANT_UnresolvedClassInError: {
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	1575 Symbol* sym = klass_name_at(idx);
0 a61af66fc99e Initial load duke parents: diff changeset	1576 classmap->add_entry(sym, idx);
a61af66fc99e Initial load duke parents: diff changeset	1577 DBG(printf("adding class entry %s = %d\n", sym->as_utf8(), idx));
a61af66fc99e Initial load duke parents: diff changeset	1578 break;
a61af66fc99e Initial load duke parents: diff changeset	1579 }
a61af66fc99e Initial load duke parents: diff changeset	1580 case JVM_CONSTANT_Long:
a61af66fc99e Initial load duke parents: diff changeset	1581 case JVM_CONSTANT_Double: {
a61af66fc99e Initial load duke parents: diff changeset	1582 idx++; // Both Long and Double take two cpool slots
a61af66fc99e Initial load duke parents: diff changeset	1583 break;
a61af66fc99e Initial load duke parents: diff changeset	1584 }
a61af66fc99e Initial load duke parents: diff changeset	1585 }
a61af66fc99e Initial load duke parents: diff changeset	1586 }
a61af66fc99e Initial load duke parents: diff changeset	1587 return size;
a61af66fc99e Initial load duke parents: diff changeset	1588 } /* end hash_utf8_entries_to */
a61af66fc99e Initial load duke parents: diff changeset	1589
a61af66fc99e Initial load duke parents: diff changeset	1590
a61af66fc99e Initial load duke parents: diff changeset	1591 // Copy cpool bytes.
a61af66fc99e Initial load duke parents: diff changeset	1592 // Returns:
a61af66fc99e Initial load duke parents: diff changeset	1593 // 0, in case of OutOfMemoryError
a61af66fc99e Initial load duke parents: diff changeset	1594 // -1, in case of internal error
a61af66fc99e Initial load duke parents: diff changeset	1595 // > 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	1596 int ConstantPool::copy_cpool_bytes(int cpool_size,
0 a61af66fc99e Initial load duke parents: diff changeset	1597 SymbolHashMap* tbl,
a61af66fc99e Initial load duke parents: diff changeset	1598 unsigned char *bytes) {
a61af66fc99e Initial load duke parents: diff changeset	1599 u2 idx1, idx2;
a61af66fc99e Initial load duke parents: diff changeset	1600 jint size = 0;
a61af66fc99e Initial load duke parents: diff changeset	1601 jint cnt = length();
a61af66fc99e Initial load duke parents: diff changeset	1602 unsigned char *start_bytes = bytes;
a61af66fc99e Initial load duke parents: diff changeset	1603
a61af66fc99e Initial load duke parents: diff changeset	1604 for (jint idx = 1; idx < cnt; idx++) {
a61af66fc99e Initial load duke parents: diff changeset	1605 u1 tag = tag_at(idx).value();
a61af66fc99e Initial load duke parents: diff changeset	1606 jint ent_size = cpool_entry_size(idx);
a61af66fc99e Initial load duke parents: diff changeset	1607
a61af66fc99e Initial load duke parents: diff changeset	1608 assert(size + ent_size <= cpool_size, "Size mismatch");
a61af66fc99e Initial load duke parents: diff changeset	1609
a61af66fc99e Initial load duke parents: diff changeset	1610 *bytes = tag;
a61af66fc99e Initial load duke parents: diff changeset	1611 DBG(printf("#%03hd tag=%03hd, ", idx, tag));
a61af66fc99e Initial load duke parents: diff changeset	1612 switch(tag) {
a61af66fc99e Initial load duke parents: diff changeset	1613 case JVM_CONSTANT_Invalid: {
a61af66fc99e Initial load duke parents: diff changeset	1614 DBG(printf("JVM_CONSTANT_Invalid"));
a61af66fc99e Initial load duke parents: diff changeset	1615 break;
a61af66fc99e Initial load duke parents: diff changeset	1616 }
a61af66fc99e Initial load duke parents: diff changeset	1617 case JVM_CONSTANT_Unicode: {
a61af66fc99e Initial load duke parents: diff changeset	1618 assert(false, "Wrong constant pool tag: JVM_CONSTANT_Unicode");
a61af66fc99e Initial load duke parents: diff changeset	1619 DBG(printf("JVM_CONSTANT_Unicode"));
a61af66fc99e Initial load duke parents: diff changeset	1620 break;
a61af66fc99e Initial load duke parents: diff changeset	1621 }
a61af66fc99e Initial load duke parents: diff changeset	1622 case JVM_CONSTANT_Utf8: {
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	1623 Symbol* sym = symbol_at(idx);
0 a61af66fc99e Initial load duke parents: diff changeset	1624 char* str = sym->as_utf8();
a61af66fc99e Initial load duke parents: diff changeset	1625 // Warning! It's crashing on x86 with len = sym->utf8_length()
a61af66fc99e Initial load duke parents: diff changeset	1626 int len = (int) strlen(str);
a61af66fc99e Initial load duke parents: diff changeset	1627 Bytes::put_Java_u2((address) (bytes+1), (u2) len);
a61af66fc99e Initial load duke parents: diff changeset	1628 for (int i = 0; i < len; i++) {
a61af66fc99e Initial load duke parents: diff changeset	1629 bytes[3+i] = (u1) str[i];
a61af66fc99e Initial load duke parents: diff changeset	1630 }
a61af66fc99e Initial load duke parents: diff changeset	1631 DBG(printf("JVM_CONSTANT_Utf8: %s ", str));
a61af66fc99e Initial load duke parents: diff changeset	1632 break;
a61af66fc99e Initial load duke parents: diff changeset	1633 }
a61af66fc99e Initial load duke parents: diff changeset	1634 case JVM_CONSTANT_Integer: {
a61af66fc99e Initial load duke parents: diff changeset	1635 jint val = int_at(idx);
a61af66fc99e Initial load duke parents: diff changeset	1636 Bytes::put_Java_u4((address) (bytes+1), (u4)&val);
a61af66fc99e Initial load duke parents: diff changeset	1637 break;
a61af66fc99e Initial load duke parents: diff changeset	1638 }
a61af66fc99e Initial load duke parents: diff changeset	1639 case JVM_CONSTANT_Float: {
a61af66fc99e Initial load duke parents: diff changeset	1640 jfloat val = float_at(idx);
a61af66fc99e Initial load duke parents: diff changeset	1641 Bytes::put_Java_u4((address) (bytes+1), (u4)&val);
a61af66fc99e Initial load duke parents: diff changeset	1642 break;
a61af66fc99e Initial load duke parents: diff changeset	1643 }
a61af66fc99e Initial load duke parents: diff changeset	1644 case JVM_CONSTANT_Long: {
a61af66fc99e Initial load duke parents: diff changeset	1645 jlong val = long_at(idx);
a61af66fc99e Initial load duke parents: diff changeset	1646 Bytes::put_Java_u8((address) (bytes+1), (u8)&val);
a61af66fc99e Initial load duke parents: diff changeset	1647 idx++; // Long takes two cpool slots
a61af66fc99e Initial load duke parents: diff changeset	1648 break;
a61af66fc99e Initial load duke parents: diff changeset	1649 }
a61af66fc99e Initial load duke parents: diff changeset	1650 case JVM_CONSTANT_Double: {
a61af66fc99e Initial load duke parents: diff changeset	1651 jdouble val = double_at(idx);
a61af66fc99e Initial load duke parents: diff changeset	1652 Bytes::put_Java_u8((address) (bytes+1), (u8)&val);
a61af66fc99e Initial load duke parents: diff changeset	1653 idx++; // Double takes two cpool slots
a61af66fc99e Initial load duke parents: diff changeset	1654 break;
a61af66fc99e Initial load duke parents: diff changeset	1655 }
a61af66fc99e Initial load duke parents: diff changeset	1656 case JVM_CONSTANT_Class:
a61af66fc99e Initial load duke parents: diff changeset	1657 case JVM_CONSTANT_UnresolvedClass:
a61af66fc99e Initial load duke parents: diff changeset	1658 case JVM_CONSTANT_UnresolvedClassInError: {
a61af66fc99e Initial load duke parents: diff changeset	1659 *bytes = JVM_CONSTANT_Class;
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	1660 Symbol* sym = klass_name_at(idx);
0 a61af66fc99e Initial load duke parents: diff changeset	1661 idx1 = tbl->symbol_to_value(sym);
a61af66fc99e Initial load duke parents: diff changeset	1662 assert(idx1 != 0, "Have not found a hashtable entry");
a61af66fc99e Initial load duke parents: diff changeset	1663 Bytes::put_Java_u2((address) (bytes+1), idx1);
a61af66fc99e Initial load duke parents: diff changeset	1664 DBG(printf("JVM_CONSTANT_Class: idx=#%03hd, %s", idx1, sym->as_utf8()));
a61af66fc99e Initial load duke parents: diff changeset	1665 break;
a61af66fc99e Initial load duke parents: diff changeset	1666 }
a61af66fc99e Initial load duke parents: diff changeset	1667 case JVM_CONSTANT_String: {
a61af66fc99e Initial load duke parents: diff changeset	1668 *bytes = JVM_CONSTANT_String;
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	1669 Symbol* sym = unresolved_string_at(idx);
0 a61af66fc99e Initial load duke parents: diff changeset	1670 idx1 = tbl->symbol_to_value(sym);
a61af66fc99e Initial load duke parents: diff changeset	1671 assert(idx1 != 0, "Have not found a hashtable entry");
a61af66fc99e Initial load duke parents: diff changeset	1672 Bytes::put_Java_u2((address) (bytes+1), idx1);
9060 cc32ccaaf47f 8003310: Enable -Wunused-function when compiling with gcc mikael parents: 8782 diff changeset	1673 DBG(printf("JVM_CONSTANT_String: idx=#%03hd, %s", idx1, sym->as_utf8()));
0 a61af66fc99e Initial load duke parents: diff changeset	1674 break;
a61af66fc99e Initial load duke parents: diff changeset	1675 }
a61af66fc99e Initial load duke parents: diff changeset	1676 case JVM_CONSTANT_Fieldref:
a61af66fc99e Initial load duke parents: diff changeset	1677 case JVM_CONSTANT_Methodref:
a61af66fc99e Initial load duke parents: diff changeset	1678 case JVM_CONSTANT_InterfaceMethodref: {
a61af66fc99e Initial load duke parents: diff changeset	1679 idx1 = uncached_klass_ref_index_at(idx);
a61af66fc99e Initial load duke parents: diff changeset	1680 idx2 = uncached_name_and_type_ref_index_at(idx);
a61af66fc99e Initial load duke parents: diff changeset	1681 Bytes::put_Java_u2((address) (bytes+1), idx1);
a61af66fc99e Initial load duke parents: diff changeset	1682 Bytes::put_Java_u2((address) (bytes+3), idx2);
a61af66fc99e Initial load duke parents: diff changeset	1683 DBG(printf("JVM_CONSTANT_Methodref: %hd %hd", idx1, idx2));
a61af66fc99e Initial load duke parents: diff changeset	1684 break;
a61af66fc99e Initial load duke parents: diff changeset	1685 }
a61af66fc99e Initial load duke parents: diff changeset	1686 case JVM_CONSTANT_NameAndType: {
a61af66fc99e Initial load duke parents: diff changeset	1687 idx1 = name_ref_index_at(idx);
a61af66fc99e Initial load duke parents: diff changeset	1688 idx2 = signature_ref_index_at(idx);
a61af66fc99e Initial load duke parents: diff changeset	1689 Bytes::put_Java_u2((address) (bytes+1), idx1);
a61af66fc99e Initial load duke parents: diff changeset	1690 Bytes::put_Java_u2((address) (bytes+3), idx2);
a61af66fc99e Initial load duke parents: diff changeset	1691 DBG(printf("JVM_CONSTANT_NameAndType: %hd %hd", idx1, idx2));
a61af66fc99e Initial load duke parents: diff changeset	1692 break;
a61af66fc99e Initial load duke parents: diff changeset	1693 }
a61af66fc99e Initial load duke parents: diff changeset	1694 case JVM_CONSTANT_ClassIndex: {
a61af66fc99e Initial load duke parents: diff changeset	1695 *bytes = JVM_CONSTANT_Class;
a61af66fc99e Initial load duke parents: diff changeset	1696 idx1 = klass_index_at(idx);
a61af66fc99e Initial load duke parents: diff changeset	1697 Bytes::put_Java_u2((address) (bytes+1), idx1);
a61af66fc99e Initial load duke parents: diff changeset	1698 DBG(printf("JVM_CONSTANT_ClassIndex: %hd", idx1));
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_StringIndex: {
a61af66fc99e Initial load duke parents: diff changeset	1702 *bytes = JVM_CONSTANT_String;
a61af66fc99e Initial load duke parents: diff changeset	1703 idx1 = string_index_at(idx);
a61af66fc99e Initial load duke parents: diff changeset	1704 Bytes::put_Java_u2((address) (bytes+1), idx1);
a61af66fc99e Initial load duke parents: diff changeset	1705 DBG(printf("JVM_CONSTANT_StringIndex: %hd", idx1));
a61af66fc99e Initial load duke parents: diff changeset	1706 break;
a61af66fc99e Initial load duke parents: diff changeset	1707 }
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1708 case JVM_CONSTANT_MethodHandle:
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1709 case JVM_CONSTANT_MethodHandleInError: {
1602 136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	1710 *bytes = JVM_CONSTANT_MethodHandle;
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	1711 int kind = method_handle_ref_kind_at(idx);
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	1712 idx1 = method_handle_index_at(idx);
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	1713 *(bytes+1) = (unsigned char) kind;
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	1714 Bytes::put_Java_u2((address) (bytes+2), idx1);
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	1715 DBG(printf("JVM_CONSTANT_MethodHandle: %d %hd", kind, idx1));
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	1716 break;
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	1717 }
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1718 case JVM_CONSTANT_MethodType:
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1719 case JVM_CONSTANT_MethodTypeInError: {
1602 136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	1720 *bytes = JVM_CONSTANT_MethodType;
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	1721 idx1 = method_type_index_at(idx);
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	1722 Bytes::put_Java_u2((address) (bytes+1), idx1);
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	1723 DBG(printf("JVM_CONSTANT_MethodType: %hd", idx1));
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	1724 break;
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	1725 }
1660 083fde3b838e 6964498: JSR 292 invokedynamic sites need local bootstrap methods jrose parents: 1602 diff changeset	1726 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	1727 *bytes = tag;
dad31fc330cd 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute jrose parents: 1972 diff changeset	1728 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	1729 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	1730 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	1731 Bytes::put_Java_u2((address) (bytes+1), idx1);
083fde3b838e 6964498: JSR 292 invokedynamic sites need local bootstrap methods jrose parents: 1602 diff changeset	1732 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	1733 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	1734 break;
083fde3b838e 6964498: JSR 292 invokedynamic sites need local bootstrap methods jrose parents: 1602 diff changeset	1735 }
0 a61af66fc99e Initial load duke parents: diff changeset	1736 }
a61af66fc99e Initial load duke parents: diff changeset	1737 DBG(printf("\n"));
a61af66fc99e Initial load duke parents: diff changeset	1738 bytes += ent_size;
a61af66fc99e Initial load duke parents: diff changeset	1739 size += ent_size;
a61af66fc99e Initial load duke parents: diff changeset	1740 }
a61af66fc99e Initial load duke parents: diff changeset	1741 assert(size == cpool_size, "Size mismatch");
a61af66fc99e Initial load duke parents: diff changeset	1742
a61af66fc99e Initial load duke parents: diff changeset	1743 // Keep temorarily for debugging until it's stable.
a61af66fc99e Initial load duke parents: diff changeset	1744 DBG(print_cpool_bytes(cnt, start_bytes));
a61af66fc99e Initial load duke parents: diff changeset	1745 return (int)(bytes - start_bytes);
a61af66fc99e Initial load duke parents: diff changeset	1746 } /* end copy_cpool_bytes */
a61af66fc99e Initial load duke parents: diff changeset	1747
9060 cc32ccaaf47f 8003310: Enable -Wunused-function when compiling with gcc mikael parents: 8782 diff changeset	1748 #undef DBG
cc32ccaaf47f 8003310: Enable -Wunused-function when compiling with gcc mikael parents: 8782 diff changeset	1749
0 a61af66fc99e Initial load duke parents: diff changeset	1750
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1751 void ConstantPool::set_on_stack(const bool value) {
7949 5daaddd917a1 8006040: NPG: on_stack processing wastes space in ConstantPool coleenp parents: 7624 diff changeset	1752 if (value) {
5daaddd917a1 8006040: NPG: on_stack processing wastes space in ConstantPool coleenp parents: 7624 diff changeset	1753 _flags \|= _on_stack;
5daaddd917a1 8006040: NPG: on_stack processing wastes space in ConstantPool coleenp parents: 7624 diff changeset	1754 } else {
5daaddd917a1 8006040: NPG: on_stack processing wastes space in ConstantPool coleenp parents: 7624 diff changeset	1755 _flags &= ~_on_stack;
5daaddd917a1 8006040: NPG: on_stack processing wastes space in ConstantPool coleenp parents: 7624 diff changeset	1756 }
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1757 if (value) MetadataOnStackMark::record(this);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1758 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1759
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1760 // 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	1761 // the oop array for resolved references are created.
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1762 // 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	1763 // 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	1764 // so only defer the pseudo_strings.
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1765 void ConstantPool::patch_resolved_references(
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1766 GrowableArray<Handle>* cp_patches) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1767 assert(EnableInvokeDynamic, "");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1768 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	1769 Handle patch = cp_patches->at(index);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1770 if (patch.not_null()) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1771 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	1772 // Patching a string means pre-resolving it.
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1773 // The spelling in the constant pool is ignored.
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1774 // The constant reference may be any object whatever.
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1775 // 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	1776 // 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	1777 // explicitly, because it may require scavenging.
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1778 int obj_index = cp_to_object_index(index);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1779 pseudo_string_at_put(index, obj_index, patch());
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1780 DEBUG_ONLY(cp_patches->at_put(index, Handle());)
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1781 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1782 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1783 #ifdef ASSERT
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1784 // Ensure that all the patches have been used.
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1785 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	1786 assert(cp_patches->at(index).is_null(),
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1787 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	1788 index,
6940 18fb7da42534 8000725: NPG: method_holder() and pool_holder() and pool_holder field should be InstanceKlass coleenp parents: 6934 diff changeset	1789 pool_holder()->external_name()));
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1790 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1791 #endif // ASSERT
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1792 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1793
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1794 #ifndef PRODUCT
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1795
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1796 // 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	1797 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	1798 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	1799 constantPoolHandle cp(THREAD, (ConstantPool*)obj);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1800 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	1801
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1802 for (int i = 0; i< cp->length(); i++) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1803 if (cp->tag_at(i).is_unresolved_klass()) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1804 // This will force loading of the class
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1805 Klass* klass = cp->klass_at(i, CHECK);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1806 if (klass->oop_is_instance()) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1807 // Force initialization of class
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1808 InstanceKlass::cast(klass)->initialize(CHECK);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1809 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1810 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1811 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1812 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1813
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1814 #endif
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 // Printing
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1818
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1819 void ConstantPool::print_on(outputStream* st) const {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1820 EXCEPTION_MARK;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1821 assert(is_constantPool(), "must be constantPool");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1822 st->print_cr(internal_name());
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1823 if (flags() != 0) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1824 st->print(" - flags: 0x%x", flags());
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1825 if (has_preresolution()) st->print(" has_preresolution");
7949 5daaddd917a1 8006040: NPG: on_stack processing wastes space in ConstantPool coleenp parents: 7624 diff changeset	1826 if (on_stack()) st->print(" on_stack");
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1827 st->cr();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1828 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1829 if (pool_holder() != NULL) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1830 st->print_cr(" - holder: " INTPTR_FORMAT, pool_holder());
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1831 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1832 st->print_cr(" - cache: " INTPTR_FORMAT, cache());
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1833 st->print_cr(" - resolved_references: " INTPTR_FORMAT, resolved_references());
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1834 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	1835
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1836 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	1837 ((ConstantPool*)this)->print_entry_on(index, st);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1838 switch (tag_at(index).value()) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1839 case JVM_CONSTANT_Long :
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1840 case JVM_CONSTANT_Double :
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1841 index++; // Skip entry following eigth-byte constant
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1842 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1843
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1844 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1845 st->cr();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1846 }
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 // Print one constant pool entry
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1849 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	1850 EXCEPTION_MARK;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1851 st->print(" - %3d : ", index);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1852 tag_at(index).print_on(st);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1853 st->print(" : ");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1854 switch (tag_at(index).value()) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1855 case JVM_CONSTANT_Class :
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1856 { 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	1857 guarantee(k != NULL, "need klass");
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1858 k->print_value_on(st);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1859 st->print(" {0x%lx}", (address)k);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1860 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1861 break;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1862 case JVM_CONSTANT_Fieldref :
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1863 case JVM_CONSTANT_Methodref :
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1864 case JVM_CONSTANT_InterfaceMethodref :
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1865 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	1866 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	1867 break;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1868 case JVM_CONSTANT_String :
8104 f16e75e0cf11 8000797: NPG: is_pseudo_string_at() doesn't work coleenp parents: 7964 diff changeset	1869 if (is_pseudo_string_at(index)) {
f16e75e0cf11 8000797: NPG: is_pseudo_string_at() doesn't work coleenp parents: 7964 diff changeset	1870 oop anObj = pseudo_string_at(index);
f16e75e0cf11 8000797: NPG: is_pseudo_string_at() doesn't work coleenp parents: 7964 diff changeset	1871 anObj->print_value_on(st);
f16e75e0cf11 8000797: NPG: is_pseudo_string_at() doesn't work coleenp parents: 7964 diff changeset	1872 st->print(" {0x%lx}", (address)anObj);
f16e75e0cf11 8000797: NPG: is_pseudo_string_at() doesn't work coleenp parents: 7964 diff changeset	1873 } else {
f16e75e0cf11 8000797: NPG: is_pseudo_string_at() doesn't work coleenp parents: 7964 diff changeset	1874 unresolved_string_at(index)->print_value_on(st);
f16e75e0cf11 8000797: NPG: is_pseudo_string_at() doesn't work coleenp parents: 7964 diff changeset	1875 }
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1876 break;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1877 case JVM_CONSTANT_Integer :
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1878 st->print("%d", int_at(index));
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1879 break;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1880 case JVM_CONSTANT_Float :
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1881 st->print("%f", float_at(index));
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1882 break;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1883 case JVM_CONSTANT_Long :
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1884 st->print_jlong(long_at(index));
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1885 break;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1886 case JVM_CONSTANT_Double :
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1887 st->print("%lf", double_at(index));
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1888 break;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1889 case JVM_CONSTANT_NameAndType :
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1890 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	1891 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	1892 break;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1893 case JVM_CONSTANT_Utf8 :
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1894 symbol_at(index)->print_value_on(st);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1895 break;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1896 case JVM_CONSTANT_UnresolvedClass : // fall-through
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1897 case JVM_CONSTANT_UnresolvedClassInError: {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1898 // unresolved_klass_at requires lock or safe world.
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1899 CPSlot entry = slot_at(index);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1900 if (entry.is_resolved()) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1901 entry.get_klass()->print_value_on(st);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1902 } else {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1903 entry.get_symbol()->print_value_on(st);
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 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1906 break;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1907 case JVM_CONSTANT_MethodHandle :
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1908 case JVM_CONSTANT_MethodHandleInError :
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1909 st->print("ref_kind=%d", method_handle_ref_kind_at(index));
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1910 st->print(" ref_index=%d", method_handle_index_at(index));
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1911 break;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1912 case JVM_CONSTANT_MethodType :
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1913 case JVM_CONSTANT_MethodTypeInError :
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1914 st->print("signature_index=%d", method_type_index_at(index));
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1915 break;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1916 case JVM_CONSTANT_InvokeDynamic :
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 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	1919 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	1920 int argc = invoke_dynamic_argument_count_at(index);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1921 if (argc > 0) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1922 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	1923 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	1924 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	1925 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1926 st->print("}");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1927 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1928 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1929 break;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1930 default:
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1931 ShouldNotReachHere();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1932 break;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1933 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1934 st->cr();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1935 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1936
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1937 void ConstantPool::print_value_on(outputStream* st) const {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1938 assert(is_constantPool(), "must be constantPool");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1939 st->print("constant pool [%d]", length());
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1940 if (has_preresolution()) st->print("/preresolution");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1941 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	1942 print_address_on(st);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1943 st->print(" for ");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1944 pool_holder()->print_value_on(st);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1945 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	1946 bool extra = (pool_holder()->constants() != this);
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1947 if (extra) st->print(" (extra)");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1948 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1949 if (cache() != NULL) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1950 st->print(" cache=" PTR_FORMAT, cache());
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1951 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1952 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1953
7956 16fb9f942703 6479360: PrintClassHistogram improvements acorn parents: 7949 diff changeset	1954 #if INCLUDE_SERVICES
16fb9f942703 6479360: PrintClassHistogram improvements acorn parents: 7949 diff changeset	1955 // Size Statistics
16fb9f942703 6479360: PrintClassHistogram improvements acorn parents: 7949 diff changeset	1956 void ConstantPool::collect_statistics(KlassSizeStats *sz) const {
16fb9f942703 6479360: PrintClassHistogram improvements acorn parents: 7949 diff changeset	1957 sz->_cp_all_bytes += (sz->_cp_bytes = sz->count(this));
16fb9f942703 6479360: PrintClassHistogram improvements acorn parents: 7949 diff changeset	1958 sz->_cp_all_bytes += (sz->_cp_tags_bytes = sz->count_array(tags()));
16fb9f942703 6479360: PrintClassHistogram improvements acorn parents: 7949 diff changeset	1959 sz->_cp_all_bytes += (sz->_cp_cache_bytes = sz->count(cache()));
16fb9f942703 6479360: PrintClassHistogram improvements acorn parents: 7949 diff changeset	1960 sz->_cp_all_bytes += (sz->_cp_operands_bytes = sz->count_array(operands()));
16fb9f942703 6479360: PrintClassHistogram improvements acorn parents: 7949 diff changeset	1961 sz->_cp_all_bytes += (sz->_cp_refmap_bytes = sz->count_array(reference_map()));
16fb9f942703 6479360: PrintClassHistogram improvements acorn parents: 7949 diff changeset	1962
16fb9f942703 6479360: PrintClassHistogram improvements acorn parents: 7949 diff changeset	1963 sz->_ro_bytes += sz->_cp_operands_bytes + sz->_cp_tags_bytes +
16fb9f942703 6479360: PrintClassHistogram improvements acorn parents: 7949 diff changeset	1964 sz->_cp_refmap_bytes;
16fb9f942703 6479360: PrintClassHistogram improvements acorn parents: 7949 diff changeset	1965 sz->_rw_bytes += sz->_cp_bytes + sz->_cp_cache_bytes;
16fb9f942703 6479360: PrintClassHistogram improvements acorn parents: 7949 diff changeset	1966 }
16fb9f942703 6479360: PrintClassHistogram improvements acorn parents: 7949 diff changeset	1967 #endif // INCLUDE_SERVICES
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1968
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1969 // Verification
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1970
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1971 void ConstantPool::verify_on(outputStream* st) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1972 guarantee(is_constantPool(), "object must be constant pool");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1973 for (int i = 0; i< length(); i++) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1974 constantTag tag = tag_at(i);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1975 CPSlot entry = slot_at(i);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1976 if (tag.is_klass()) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1977 if (entry.is_resolved()) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1978 guarantee(entry.get_klass()->is_metadata(), "should be metadata");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1979 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	1980 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1981 } else if (tag.is_unresolved_klass()) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1982 if (entry.is_resolved()) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1983 guarantee(entry.get_klass()->is_metadata(), "should be metadata");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1984 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	1985 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1986 } else if (tag.is_symbol()) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1987 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	1988 } else if (tag.is_string()) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1989 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	1990 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1991 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1992 if (cache() != NULL) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1993 // 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	1994 // 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	1995 guarantee(cache()->is_metadata(), "should be metadata");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1996 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	1997 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1998 if (pool_holder() != NULL) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	1999 // 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	2000 // used during constant pool merging
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2001 guarantee(pool_holder()->is_metadata(), "should be metadata");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2002 guarantee(pool_holder()->is_klass(), "should be klass");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2003 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6266 diff changeset	2004 }
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
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	2007 void SymbolHashMap::add_entry(Symbol* sym, u2 value) {
0 a61af66fc99e Initial load duke parents: diff changeset	2008 char *str = sym->as_utf8();
a61af66fc99e Initial load duke parents: diff changeset	2009 unsigned int hash = compute_hash(str, sym->utf8_length());
a61af66fc99e Initial load duke parents: diff changeset	2010 unsigned int index = hash % table_size();
a61af66fc99e Initial load duke parents: diff changeset	2011
a61af66fc99e Initial load duke parents: diff changeset	2012 // check if already in map
a61af66fc99e Initial load duke parents: diff changeset	2013 // we prefer the first entry since it is more likely to be what was used in
a61af66fc99e Initial load duke parents: diff changeset	2014 // the class file
a61af66fc99e Initial load duke parents: diff changeset	2015 for (SymbolHashMapEntry *en = bucket(index); en != NULL; en = en->next()) {
a61af66fc99e Initial load duke parents: diff changeset	2016 assert(en->symbol() != NULL, "SymbolHashMapEntry symbol is NULL");
a61af66fc99e Initial load duke parents: diff changeset	2017 if (en->hash() == hash && en->symbol() == sym) {
a61af66fc99e Initial load duke parents: diff changeset	2018 return; // already there
a61af66fc99e Initial load duke parents: diff changeset	2019 }
a61af66fc99e Initial load duke parents: diff changeset	2020 }
a61af66fc99e Initial load duke parents: diff changeset	2021
a61af66fc99e Initial load duke parents: diff changeset	2022 SymbolHashMapEntry* entry = new SymbolHashMapEntry(hash, sym, value);
a61af66fc99e Initial load duke parents: diff changeset	2023 entry->set_next(bucket(index));
a61af66fc99e Initial load duke parents: diff changeset	2024 _buckets[index].set_entry(entry);
a61af66fc99e Initial load duke parents: diff changeset	2025 assert(entry->symbol() != NULL, "SymbolHashMapEntry symbol is NULL");
a61af66fc99e Initial load duke parents: diff changeset	2026 }
a61af66fc99e Initial load duke parents: diff changeset	2027
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	2028 SymbolHashMapEntry* SymbolHashMap::find_entry(Symbol* sym) {
0 a61af66fc99e Initial load duke parents: diff changeset	2029 assert(sym != NULL, "SymbolHashMap::find_entry - symbol is NULL");
a61af66fc99e Initial load duke parents: diff changeset	2030 char *str = sym->as_utf8();
a61af66fc99e Initial load duke parents: diff changeset	2031 int len = sym->utf8_length();
a61af66fc99e Initial load duke parents: diff changeset	2032 unsigned int hash = SymbolHashMap::compute_hash(str, len);
a61af66fc99e Initial load duke parents: diff changeset	2033 unsigned int index = hash % table_size();
a61af66fc99e Initial load duke parents: diff changeset	2034 for (SymbolHashMapEntry *en = bucket(index); en != NULL; en = en->next()) {
a61af66fc99e Initial load duke parents: diff changeset	2035 assert(en->symbol() != NULL, "SymbolHashMapEntry symbol is NULL");
a61af66fc99e Initial load duke parents: diff changeset	2036 if (en->hash() == hash && en->symbol() == sym) {
a61af66fc99e Initial load duke parents: diff changeset	2037 return en;
a61af66fc99e Initial load duke parents: diff changeset	2038 }
a61af66fc99e Initial load duke parents: diff changeset	2039 }
a61af66fc99e Initial load duke parents: diff changeset	2040 return NULL;
a61af66fc99e Initial load duke parents: diff changeset	2041 }

Mercurial > hg > truffle

annotate src/share/vm/oops/constantPool.cpp @ 9126:bc26f978b0ce