truffle: src/share/vm/oops/constantPoolOop.hpp annotate

annotate src/share/vm/oops/constantPoolOop.hpp @ 4155:394404b2d9bd

Removed strict requirement for GRAAL environment variable. It only needs to be set now if the graal directory is not in the directory hierarchy of GraalVM JDK.

author	Doug Simon <doug.simon@oracle.com>
date	Wed, 21 Dec 2011 11:25:27 +0100
parents	96c40b338c1a
children	957c266d8bc5

rev	line source
0 a61af66fc99e Initial load duke parents: diff changeset	1 /*
2416 38fea01eb669 6817525: turn on method handle functionality by default for JSR 292 twisti parents: 2192 diff changeset	2 * Copyright (c) 1997, 2011, 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: 1138 diff changeset	19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
c18cbe5936b8 6941466: Oracle rebranding changes for Hotspot repositories trims parents: 1138 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: 1138 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 #ifndef SHARE_VM_OOPS_CONSTANTPOOLOOP_HPP
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1913 diff changeset	26 #define SHARE_VM_OOPS_CONSTANTPOOLOOP_HPP
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1913 diff changeset	27
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1913 diff changeset	28 #include "oops/arrayOop.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1913 diff changeset	29 #include "oops/cpCacheOop.hpp"
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	30 #include "oops/symbol.hpp"
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1913 diff changeset	31 #include "oops/typeArrayOop.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1913 diff changeset	32 #include "utilities/constantTag.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1913 diff changeset	33 #ifdef TARGET_ARCH_x86
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1913 diff changeset	34 # include "bytes_x86.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1913 diff changeset	35 #endif
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1913 diff changeset	36 #ifdef TARGET_ARCH_sparc
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1913 diff changeset	37 # include "bytes_sparc.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1913 diff changeset	38 #endif
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1913 diff changeset	39 #ifdef TARGET_ARCH_zero
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1913 diff changeset	40 # include "bytes_zero.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1913 diff changeset	41 #endif
2192 b92c45f2bc75 7016023: Enable building ARM and PPC from src/closed repository bobv parents: 2177 diff changeset	42 #ifdef TARGET_ARCH_arm
b92c45f2bc75 7016023: Enable building ARM and PPC from src/closed repository bobv parents: 2177 diff changeset	43 # include "bytes_arm.hpp"
b92c45f2bc75 7016023: Enable building ARM and PPC from src/closed repository bobv parents: 2177 diff changeset	44 #endif
b92c45f2bc75 7016023: Enable building ARM and PPC from src/closed repository bobv parents: 2177 diff changeset	45 #ifdef TARGET_ARCH_ppc
b92c45f2bc75 7016023: Enable building ARM and PPC from src/closed repository bobv parents: 2177 diff changeset	46 # include "bytes_ppc.hpp"
b92c45f2bc75 7016023: Enable building ARM and PPC from src/closed repository bobv parents: 2177 diff changeset	47 #endif
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1913 diff changeset	48
0 a61af66fc99e Initial load duke parents: diff changeset	49 // A constantPool is an array containing class constants as described in the
a61af66fc99e Initial load duke parents: diff changeset	50 // class file.
a61af66fc99e Initial load duke parents: diff changeset	51 //
a61af66fc99e Initial load duke parents: diff changeset	52 // Most of the constant pool entries are written during class parsing, which
a61af66fc99e Initial load duke parents: diff changeset	53 // is safe. For klass and string types, the constant pool entry is
a61af66fc99e Initial load duke parents: diff changeset	54 // modified when the entry is resolved. If a klass or string constant pool
a61af66fc99e Initial load duke parents: diff changeset	55 // entry is read without a lock, only the resolved state guarantees that
a61af66fc99e Initial load duke parents: diff changeset	56 // the entry in the constant pool is a klass or String object and
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	57 // not a Symbol*.
0 a61af66fc99e Initial load duke parents: diff changeset	58
a61af66fc99e Initial load duke parents: diff changeset	59 class SymbolHashMap;
a61af66fc99e Initial load duke parents: diff changeset	60
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	61 class CPSlot VALUE_OBJ_CLASS_SPEC {
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	62 intptr_t _ptr;
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	63 public:
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	64 CPSlot(intptr_t ptr): _ptr(ptr) {}
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	65 CPSlot(void* ptr): _ptr((intptr_t)ptr) {}
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	66 CPSlot(oop ptr): _ptr((intptr_t)ptr) {}
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	67 CPSlot(Symbol* ptr): _ptr((intptr_t)ptr \| 1) {}
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	68
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	69 intptr_t value() { return _ptr; }
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	70 bool is_oop() { return (_ptr & 1) == 0; }
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	71 bool is_metadata() { return (_ptr & 1) == 1; }
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	72
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	73 oop get_oop() {
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	74 assert(is_oop(), "bad call");
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	75 return oop(_ptr);
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	76 }
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	77 Symbol* get_symbol() {
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	78 assert(is_metadata(), "bad call");
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	79 return (Symbol*)(_ptr & ~1);
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	80 }
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	81 };
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	82
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	83 class constantPoolOopDesc : public oopDesc {
0 a61af66fc99e Initial load duke parents: diff changeset	84 friend class VMStructs;
a61af66fc99e Initial load duke parents: diff changeset	85 friend class BytecodeInterpreter; // Directly extracts an oop in the pool for fast instanceof/checkcast
a61af66fc99e Initial load duke parents: diff changeset	86 private:
a61af66fc99e Initial load duke parents: diff changeset	87 typeArrayOop _tags; // the tag array describing the constant pool's contents
a61af66fc99e Initial load duke parents: diff changeset	88 constantPoolCacheOop _cache; // the cache holding interpreter runtime information
a61af66fc99e Initial load duke parents: diff changeset	89 klassOop _pool_holder; // the corresponding class
1913 3b2dea75431e 6984311: JSR 292 needs optional bootstrap method parameters jrose parents: 1910 diff changeset	90 typeArrayOop _operands; // for variable-sized (InvokeDynamic) nodes, usually empty
431 a45484ea312d 6653858: dynamic languages need to be able to load anonymous classes jrose parents: 196 diff changeset	91 int _flags; // a few header bits to describe contents for GC
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	92 int _length; // number of elements in the array
518 0af8b0718fc9 6692899: CMS: many vm.parallel_class_loading tests fail with assert "missing Printezis mark" jmasa parents: 431 diff changeset	93 volatile bool _is_conc_safe; // if true, safe for concurrent
0af8b0718fc9 6692899: CMS: many vm.parallel_class_loading tests fail with assert "missing Printezis mark" jmasa parents: 431 diff changeset	94 // GC processing
0 a61af66fc99e Initial load duke parents: diff changeset	95 // only set to non-zero if constant pool is merged by RedefineClasses
a61af66fc99e Initial load duke parents: diff changeset	96 int _orig_length;
a61af66fc99e Initial load duke parents: diff changeset	97
a61af66fc99e Initial load duke parents: diff changeset	98 void set_tags(typeArrayOop tags) { oop_store_without_check((oop*)&_tags, tags); }
a61af66fc99e Initial load duke parents: diff changeset	99 void tag_at_put(int which, jbyte t) { tags()->byte_at_put(which, t); }
a61af66fc99e Initial load duke parents: diff changeset	100 void release_tag_at_put(int which, jbyte t) { tags()->release_byte_at_put(which, t); }
a61af66fc99e Initial load duke parents: diff changeset	101
1913 3b2dea75431e 6984311: JSR 292 needs optional bootstrap method parameters jrose parents: 1910 diff changeset	102 void set_operands(typeArrayOop operands) { oop_store_without_check((oop*)&_operands, operands); }
3b2dea75431e 6984311: JSR 292 needs optional bootstrap method parameters jrose parents: 1910 diff changeset	103
431 a45484ea312d 6653858: dynamic languages need to be able to load anonymous classes jrose parents: 196 diff changeset	104 enum FlagBit {
726 be93aad57795 6655646: dynamic languages need dynamically linked call sites jrose parents: 579 diff changeset	105 FB_has_invokedynamic = 1,
3461 81d815b05abb 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 2460 diff changeset	106 FB_has_pseudo_string = 2,
81d815b05abb 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 2460 diff changeset	107 FB_has_preresolution = 3
431 a45484ea312d 6653858: dynamic languages need to be able to load anonymous classes jrose parents: 196 diff changeset	108 };
a45484ea312d 6653858: dynamic languages need to be able to load anonymous classes jrose parents: 196 diff changeset	109
a45484ea312d 6653858: dynamic languages need to be able to load anonymous classes jrose parents: 196 diff changeset	110 int flags() const { return _flags; }
a45484ea312d 6653858: dynamic languages need to be able to load anonymous classes jrose parents: 196 diff changeset	111 void set_flags(int f) { _flags = f; }
a45484ea312d 6653858: dynamic languages need to be able to load anonymous classes jrose parents: 196 diff changeset	112 bool flag_at(FlagBit fb) const { return (_flags & (1 << (int)fb)) != 0; }
a45484ea312d 6653858: dynamic languages need to be able to load anonymous classes jrose parents: 196 diff changeset	113 void set_flag_at(FlagBit fb);
a45484ea312d 6653858: dynamic languages need to be able to load anonymous classes jrose parents: 196 diff changeset	114 // no clear_flag_at function; they only increase
a45484ea312d 6653858: dynamic languages need to be able to load anonymous classes jrose parents: 196 diff changeset	115
0 a61af66fc99e Initial load duke parents: diff changeset	116 private:
a61af66fc99e Initial load duke parents: diff changeset	117 intptr_t* base() const { return (intptr_t) (((char) this) + sizeof(constantPoolOopDesc)); }
a61af66fc99e Initial load duke parents: diff changeset	118 oop* tags_addr() { return (oop*)&_tags; }
a61af66fc99e Initial load duke parents: diff changeset	119 oop* cache_addr() { return (oop*)&_cache; }
1913 3b2dea75431e 6984311: JSR 292 needs optional bootstrap method parameters jrose parents: 1910 diff changeset	120 oop* operands_addr() { return (oop*)&_operands; }
0 a61af66fc99e Initial load duke parents: diff changeset	121
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	122 CPSlot slot_at(int which) {
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	123 assert(is_within_bounds(which), "index out of bounds");
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	124 // There's a transitional value of zero when converting from
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	125 // Symbol->0->Klass for G1 when resolving classes and strings.
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	126 // wait for the value to be non-zero (this is temporary)
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	127 volatile intptr_t adr = (intptr_t)OrderAccess::load_ptr_acquire(obj_at_addr_raw(which));
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	128 if (adr == 0 && which != 0) {
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	129 constantTag t = tag_at(which);
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	130 if (t.is_unresolved_klass() \|\| t.is_klass() \|\|
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	131 t.is_unresolved_string() \|\| t.is_string()) {
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	132 while ((adr = (intptr_t)OrderAccess::load_ptr_acquire(obj_at_addr_raw(which))) == 0);
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	133 }
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	134 }
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	135 return CPSlot(adr);
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	136 }
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	137
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	138 void slot_at_put(int which, CPSlot s) const {
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	139 assert(is_within_bounds(which), "index out of bounds");
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	140 (intptr_t)&base()[which] = s.value();
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	141 }
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	142 oop* obj_at_addr_raw(int which) const {
0 a61af66fc99e Initial load duke parents: diff changeset	143 assert(is_within_bounds(which), "index out of bounds");
a61af66fc99e Initial load duke parents: diff changeset	144 return (oop*) &base()[which];
a61af66fc99e Initial load duke parents: diff changeset	145 }
a61af66fc99e Initial load duke parents: diff changeset	146
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	147 void obj_at_put_without_check(int which, oop o) {
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	148 assert(is_within_bounds(which), "index out of bounds");
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	149 oop_store_without_check((volatile oop *)obj_at_addr_raw(which), o);
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	150 }
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	151
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	152 void obj_at_put(int which, oop o) const {
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	153 assert(is_within_bounds(which), "index out of bounds");
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	154 oop_store((volatile oop*)obj_at_addr_raw(which), o);
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	155 }
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	156
0 a61af66fc99e Initial load duke parents: diff changeset	157 jint* int_at_addr(int which) const {
a61af66fc99e Initial load duke parents: diff changeset	158 assert(is_within_bounds(which), "index out of bounds");
a61af66fc99e Initial load duke parents: diff changeset	159 return (jint*) &base()[which];
a61af66fc99e Initial load duke parents: diff changeset	160 }
a61af66fc99e Initial load duke parents: diff changeset	161
a61af66fc99e Initial load duke parents: diff changeset	162 jlong* long_at_addr(int which) const {
a61af66fc99e Initial load duke parents: diff changeset	163 assert(is_within_bounds(which), "index out of bounds");
a61af66fc99e Initial load duke parents: diff changeset	164 return (jlong*) &base()[which];
a61af66fc99e Initial load duke parents: diff changeset	165 }
a61af66fc99e Initial load duke parents: diff changeset	166
a61af66fc99e Initial load duke parents: diff changeset	167 jfloat* float_at_addr(int which) const {
a61af66fc99e Initial load duke parents: diff changeset	168 assert(is_within_bounds(which), "index out of bounds");
a61af66fc99e Initial load duke parents: diff changeset	169 return (jfloat*) &base()[which];
a61af66fc99e Initial load duke parents: diff changeset	170 }
a61af66fc99e Initial load duke parents: diff changeset	171
a61af66fc99e Initial load duke parents: diff changeset	172 jdouble* double_at_addr(int which) const {
a61af66fc99e Initial load duke parents: diff changeset	173 assert(is_within_bounds(which), "index out of bounds");
a61af66fc99e Initial load duke parents: diff changeset	174 return (jdouble*) &base()[which];
a61af66fc99e Initial load duke parents: diff changeset	175 }
a61af66fc99e Initial load duke parents: diff changeset	176
a61af66fc99e Initial load duke parents: diff changeset	177 public:
a61af66fc99e Initial load duke parents: diff changeset	178 typeArrayOop tags() const { return _tags; }
1913 3b2dea75431e 6984311: JSR 292 needs optional bootstrap method parameters jrose parents: 1910 diff changeset	179 typeArrayOop operands() const { return _operands; }
0 a61af66fc99e Initial load duke parents: diff changeset	180
431 a45484ea312d 6653858: dynamic languages need to be able to load anonymous classes jrose parents: 196 diff changeset	181 bool has_pseudo_string() const { return flag_at(FB_has_pseudo_string); }
726 be93aad57795 6655646: dynamic languages need dynamically linked call sites jrose parents: 579 diff changeset	182 bool has_invokedynamic() const { return flag_at(FB_has_invokedynamic); }
3461 81d815b05abb 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 2460 diff changeset	183 bool has_preresolution() const { return flag_at(FB_has_preresolution); }
431 a45484ea312d 6653858: dynamic languages need to be able to load anonymous classes jrose parents: 196 diff changeset	184 void set_pseudo_string() { set_flag_at(FB_has_pseudo_string); }
726 be93aad57795 6655646: dynamic languages need dynamically linked call sites jrose parents: 579 diff changeset	185 void set_invokedynamic() { set_flag_at(FB_has_invokedynamic); }
3461 81d815b05abb 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 2460 diff changeset	186 void set_preresolution() { set_flag_at(FB_has_preresolution); }
431 a45484ea312d 6653858: dynamic languages need to be able to load anonymous classes jrose parents: 196 diff changeset	187
0 a61af66fc99e Initial load duke parents: diff changeset	188 // Klass holding pool
a61af66fc99e Initial load duke parents: diff changeset	189 klassOop pool_holder() const { return _pool_holder; }
a61af66fc99e Initial load duke parents: diff changeset	190 void set_pool_holder(klassOop k) { oop_store_without_check((oop*)&_pool_holder, (oop) k); }
a61af66fc99e Initial load duke parents: diff changeset	191 oop* pool_holder_addr() { return (oop*)&_pool_holder; }
a61af66fc99e Initial load duke parents: diff changeset	192
a61af66fc99e Initial load duke parents: diff changeset	193 // Interpreter runtime support
a61af66fc99e Initial load duke parents: diff changeset	194 constantPoolCacheOop cache() const { return _cache; }
a61af66fc99e Initial load duke parents: diff changeset	195 void set_cache(constantPoolCacheOop cache){ oop_store((oop*)&_cache, cache); }
a61af66fc99e Initial load duke parents: diff changeset	196
a61af66fc99e Initial load duke parents: diff changeset	197 // Assembly code support
a61af66fc99e Initial load duke parents: diff changeset	198 static int tags_offset_in_bytes() { return offset_of(constantPoolOopDesc, _tags); }
a61af66fc99e Initial load duke parents: diff changeset	199 static int cache_offset_in_bytes() { return offset_of(constantPoolOopDesc, _cache); }
1913 3b2dea75431e 6984311: JSR 292 needs optional bootstrap method parameters jrose parents: 1910 diff changeset	200 static int operands_offset_in_bytes() { return offset_of(constantPoolOopDesc, _operands); }
0 a61af66fc99e Initial load duke parents: diff changeset	201 static int pool_holder_offset_in_bytes() { return offset_of(constantPoolOopDesc, _pool_holder); }
a61af66fc99e Initial load duke parents: diff changeset	202
a61af66fc99e Initial load duke parents: diff changeset	203 // Storing constants
a61af66fc99e Initial load duke parents: diff changeset	204
a61af66fc99e Initial load duke parents: diff changeset	205 void klass_at_put(int which, klassOop k) {
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	206 // Overwrite the old index with a GC friendly value so
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	207 // that if G1 looks during the transition during oop_store it won't
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	208 // assert the symbol is not an oop.
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	209 *obj_at_addr_raw(which) = NULL;
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	210 assert(k != NULL, "resolved class shouldn't be null");
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	211 obj_at_put_without_check(which, k);
0 a61af66fc99e Initial load duke parents: diff changeset	212 // The interpreter assumes when the tag is stored, the klass is resolved
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	213 // and the klassOop is a klass rather than a Symbol*, so we need
0 a61af66fc99e Initial load duke parents: diff changeset	214 // hardware store ordering here.
a61af66fc99e Initial load duke parents: diff changeset	215 release_tag_at_put(which, JVM_CONSTANT_Class);
a61af66fc99e Initial load duke parents: diff changeset	216 if (UseConcMarkSweepGC) {
a61af66fc99e Initial load duke parents: diff changeset	217 // In case the earlier card-mark was consumed by a concurrent
a61af66fc99e Initial load duke parents: diff changeset	218 // marking thread before the tag was updated, redirty the card.
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	219 obj_at_put_without_check(which, k);
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
a61af66fc99e Initial load duke parents: diff changeset	223 // For temporary use while constructing constant pool
a61af66fc99e Initial load duke parents: diff changeset	224 void klass_index_at_put(int which, int name_index) {
a61af66fc99e Initial load duke parents: diff changeset	225 tag_at_put(which, JVM_CONSTANT_ClassIndex);
a61af66fc99e Initial load duke parents: diff changeset	226 *int_at_addr(which) = name_index;
a61af66fc99e Initial load duke parents: diff changeset	227 }
a61af66fc99e Initial load duke parents: diff changeset	228
a61af66fc99e Initial load duke parents: diff changeset	229 // Temporary until actual use
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	230 void unresolved_klass_at_put(int which, Symbol* s) {
0 a61af66fc99e Initial load duke parents: diff changeset	231 release_tag_at_put(which, JVM_CONSTANT_UnresolvedClass);
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	232 slot_at_put(which, s);
0 a61af66fc99e Initial load duke parents: diff changeset	233 }
a61af66fc99e Initial load duke parents: diff changeset	234
1602 136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	235 void method_handle_index_at_put(int which, int ref_kind, int ref_index) {
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	236 tag_at_put(which, JVM_CONSTANT_MethodHandle);
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	237 *int_at_addr(which) = ((jint) ref_index<<16) \| ref_kind;
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	238 }
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	239
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	240 void method_type_index_at_put(int which, int ref_index) {
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	241 tag_at_put(which, JVM_CONSTANT_MethodType);
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	242 *int_at_addr(which) = ref_index;
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	243 }
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	244
2011 dad31fc330cd 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute jrose parents: 1972 diff changeset	245 void invoke_dynamic_at_put(int which, int bootstrap_specifier_index, int name_and_type_index) {
1660 083fde3b838e 6964498: JSR 292 invokedynamic sites need local bootstrap methods jrose parents: 1602 diff changeset	246 tag_at_put(which, 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	247 *int_at_addr(which) = ((jint) name_and_type_index<<16) \| bootstrap_specifier_index;
1660 083fde3b838e 6964498: JSR 292 invokedynamic sites need local bootstrap methods jrose parents: 1602 diff changeset	248 }
2011 dad31fc330cd 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute jrose parents: 1972 diff changeset	249
0 a61af66fc99e Initial load duke parents: diff changeset	250 // Temporary until actual use
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	251 void unresolved_string_at_put(int which, Symbol* s) {
0 a61af66fc99e Initial load duke parents: diff changeset	252 release_tag_at_put(which, JVM_CONSTANT_UnresolvedString);
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	253 slot_at_put(which, s);
0 a61af66fc99e Initial load duke parents: diff changeset	254 }
a61af66fc99e Initial load duke parents: diff changeset	255
a61af66fc99e Initial load duke parents: diff changeset	256 void int_at_put(int which, jint i) {
a61af66fc99e Initial load duke parents: diff changeset	257 tag_at_put(which, JVM_CONSTANT_Integer);
a61af66fc99e Initial load duke parents: diff changeset	258 *int_at_addr(which) = i;
a61af66fc99e Initial load duke parents: diff changeset	259 }
a61af66fc99e Initial load duke parents: diff changeset	260
a61af66fc99e Initial load duke parents: diff changeset	261 void long_at_put(int which, jlong l) {
a61af66fc99e Initial load duke parents: diff changeset	262 tag_at_put(which, JVM_CONSTANT_Long);
a61af66fc99e Initial load duke parents: diff changeset	263 // *long_at_addr(which) = l;
a61af66fc99e Initial load duke parents: diff changeset	264 Bytes::put_native_u8((address)long_at_addr(which), ((u8) &l));
a61af66fc99e Initial load duke parents: diff changeset	265 }
a61af66fc99e Initial load duke parents: diff changeset	266
a61af66fc99e Initial load duke parents: diff changeset	267 void float_at_put(int which, jfloat f) {
a61af66fc99e Initial load duke parents: diff changeset	268 tag_at_put(which, JVM_CONSTANT_Float);
a61af66fc99e Initial load duke parents: diff changeset	269 *float_at_addr(which) = f;
a61af66fc99e Initial load duke parents: diff changeset	270 }
a61af66fc99e Initial load duke parents: diff changeset	271
a61af66fc99e Initial load duke parents: diff changeset	272 void double_at_put(int which, jdouble d) {
a61af66fc99e Initial load duke parents: diff changeset	273 tag_at_put(which, JVM_CONSTANT_Double);
a61af66fc99e Initial load duke parents: diff changeset	274 // *double_at_addr(which) = d;
a61af66fc99e Initial load duke parents: diff changeset	275 // u8 temp = (u8) &d;
a61af66fc99e Initial load duke parents: diff changeset	276 Bytes::put_native_u8((address) double_at_addr(which), ((u8) &d));
a61af66fc99e Initial load duke parents: diff changeset	277 }
a61af66fc99e Initial load duke parents: diff changeset	278
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	279 Symbol** symbol_at_addr(int which) const {
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	280 assert(is_within_bounds(which), "index out of bounds");
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	281 return (Symbol**) &base()[which];
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	282 }
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	283
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	284 void symbol_at_put(int which, Symbol* s) {
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	285 assert(s->refcount() != 0, "should have nonzero refcount");
0 a61af66fc99e Initial load duke parents: diff changeset	286 tag_at_put(which, JVM_CONSTANT_Utf8);
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	287 slot_at_put(which, s);
0 a61af66fc99e Initial load duke parents: diff changeset	288 }
a61af66fc99e Initial load duke parents: diff changeset	289
a61af66fc99e Initial load duke parents: diff changeset	290 void string_at_put(int which, oop str) {
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	291 // Overwrite the old index with a GC friendly value so
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	292 // that if G1 looks during the transition during oop_store it won't
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	293 // assert the symbol is not an oop.
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	294 *obj_at_addr_raw(which) = NULL;
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	295 assert(str != NULL, "resolved string shouldn't be null");
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	296 obj_at_put(which, str);
0 a61af66fc99e Initial load duke parents: diff changeset	297 release_tag_at_put(which, JVM_CONSTANT_String);
a61af66fc99e Initial load duke parents: diff changeset	298 if (UseConcMarkSweepGC) {
a61af66fc99e Initial load duke parents: diff changeset	299 // In case the earlier card-mark was consumed by a concurrent
a61af66fc99e Initial load duke parents: diff changeset	300 // marking thread before the tag was updated, redirty the card.
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	301 obj_at_put_without_check(which, str);
0 a61af66fc99e Initial load duke parents: diff changeset	302 }
a61af66fc99e Initial load duke parents: diff changeset	303 }
a61af66fc99e Initial load duke parents: diff changeset	304
1138 dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1059 diff changeset	305 void object_at_put(int which, oop str) {
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	306 obj_at_put(which, str);
1138 dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1059 diff changeset	307 release_tag_at_put(which, JVM_CONSTANT_Object);
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1059 diff changeset	308 if (UseConcMarkSweepGC) {
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1059 diff changeset	309 // In case the earlier card-mark was consumed by a concurrent
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1059 diff changeset	310 // marking thread before the tag was updated, redirty the card.
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	311 obj_at_put_without_check(which, str);
1138 dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1059 diff changeset	312 }
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1059 diff changeset	313 }
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1059 diff changeset	314
0 a61af66fc99e Initial load duke parents: diff changeset	315 // For temporary use while constructing constant pool
a61af66fc99e Initial load duke parents: diff changeset	316 void string_index_at_put(int which, int string_index) {
a61af66fc99e Initial load duke parents: diff changeset	317 tag_at_put(which, JVM_CONSTANT_StringIndex);
a61af66fc99e Initial load duke parents: diff changeset	318 *int_at_addr(which) = string_index;
a61af66fc99e Initial load duke parents: diff changeset	319 }
a61af66fc99e Initial load duke parents: diff changeset	320
a61af66fc99e Initial load duke parents: diff changeset	321 void field_at_put(int which, int class_index, int name_and_type_index) {
a61af66fc99e Initial load duke parents: diff changeset	322 tag_at_put(which, JVM_CONSTANT_Fieldref);
a61af66fc99e Initial load duke parents: diff changeset	323 *int_at_addr(which) = ((jint) name_and_type_index<<16) \| class_index;
a61af66fc99e Initial load duke parents: diff changeset	324 }
a61af66fc99e Initial load duke parents: diff changeset	325
a61af66fc99e Initial load duke parents: diff changeset	326 void method_at_put(int which, int class_index, int name_and_type_index) {
a61af66fc99e Initial load duke parents: diff changeset	327 tag_at_put(which, JVM_CONSTANT_Methodref);
a61af66fc99e Initial load duke parents: diff changeset	328 *int_at_addr(which) = ((jint) name_and_type_index<<16) \| class_index;
a61af66fc99e Initial load duke parents: diff changeset	329 }
a61af66fc99e Initial load duke parents: diff changeset	330
a61af66fc99e Initial load duke parents: diff changeset	331 void interface_method_at_put(int which, int class_index, int name_and_type_index) {
a61af66fc99e Initial load duke parents: diff changeset	332 tag_at_put(which, JVM_CONSTANT_InterfaceMethodref);
a61af66fc99e Initial load duke parents: diff changeset	333 *int_at_addr(which) = ((jint) name_and_type_index<<16) \| class_index; // Not so nice
a61af66fc99e Initial load duke parents: diff changeset	334 }
a61af66fc99e Initial load duke parents: diff changeset	335
a61af66fc99e Initial load duke parents: diff changeset	336 void name_and_type_at_put(int which, int name_index, int signature_index) {
a61af66fc99e Initial load duke parents: diff changeset	337 tag_at_put(which, JVM_CONSTANT_NameAndType);
a61af66fc99e Initial load duke parents: diff changeset	338 *int_at_addr(which) = ((jint) signature_index<<16) \| name_index; // Not so nice
a61af66fc99e Initial load duke parents: diff changeset	339 }
a61af66fc99e Initial load duke parents: diff changeset	340
a61af66fc99e Initial load duke parents: diff changeset	341 // Tag query
a61af66fc99e Initial load duke parents: diff changeset	342
a61af66fc99e Initial load duke parents: diff changeset	343 constantTag tag_at(int which) const { return (constantTag)tags()->byte_at_acquire(which); }
a61af66fc99e Initial load duke parents: diff changeset	344
a61af66fc99e Initial load duke parents: diff changeset	345 // Whether the entry is a pointer that must be GC'd.
a61af66fc99e Initial load duke parents: diff changeset	346 bool is_pointer_entry(int which) {
a61af66fc99e Initial load duke parents: diff changeset	347 constantTag tag = tag_at(which);
a61af66fc99e Initial load duke parents: diff changeset	348 return tag.is_klass() \|\|
1138 dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1059 diff changeset	349 tag.is_string() \|\|
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1059 diff changeset	350 tag.is_object();
0 a61af66fc99e Initial load duke parents: diff changeset	351 }
a61af66fc99e Initial load duke parents: diff changeset	352
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	353 // Whether the entry points to an object for ldc (resolved or not)
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	354 bool is_object_entry(int which) {
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	355 constantTag tag = tag_at(which);
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	356 return is_pointer_entry(which) \|\|
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	357 tag.is_unresolved_klass() \|\|
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	358 tag.is_unresolved_string() \|\|
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	359 tag.is_symbol();
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	360 }
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	361
0 a61af66fc99e Initial load duke parents: diff changeset	362 // Fetching constants
a61af66fc99e Initial load duke parents: diff changeset	363
a61af66fc99e Initial load duke parents: diff changeset	364 klassOop klass_at(int which, TRAPS) {
a61af66fc99e Initial load duke parents: diff changeset	365 constantPoolHandle h_this(THREAD, this);
a61af66fc99e Initial load duke parents: diff changeset	366 return klass_at_impl(h_this, which, CHECK_NULL);
a61af66fc99e Initial load duke parents: diff changeset	367 }
a61af66fc99e Initial load duke parents: diff changeset	368
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	369 Symbol* klass_name_at(int which); // Returns the name, w/o resolving.
0 a61af66fc99e Initial load duke parents: diff changeset	370
a61af66fc99e Initial load duke parents: diff changeset	371 klassOop resolved_klass_at(int which) { // Used by Compiler
a61af66fc99e Initial load duke parents: diff changeset	372 guarantee(tag_at(which).is_klass(), "Corrupted constant pool");
a61af66fc99e Initial load duke parents: diff changeset	373 // Must do an acquire here in case another thread resolved the klass
a61af66fc99e Initial load duke parents: diff changeset	374 // behind our back, lest we later load stale values thru the oop.
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	375 return klassOop(CPSlot(OrderAccess::load_ptr_acquire(obj_at_addr_raw(which))).get_oop());
0 a61af66fc99e Initial load duke parents: diff changeset	376 }
a61af66fc99e Initial load duke parents: diff changeset	377
a61af66fc99e Initial load duke parents: diff changeset	378 // This method should only be used with a cpool lock or during parsing or gc
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	379 Symbol* unresolved_klass_at(int which) { // Temporary until actual use
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	380 Symbol* s = CPSlot(OrderAccess::load_ptr_acquire(obj_at_addr_raw(which))).get_symbol();
0 a61af66fc99e Initial load duke parents: diff changeset	381 // check that the klass is still unresolved.
a61af66fc99e Initial load duke parents: diff changeset	382 assert(tag_at(which).is_unresolved_klass(), "Corrupted constant pool");
a61af66fc99e Initial load duke parents: diff changeset	383 return s;
a61af66fc99e Initial load duke parents: diff changeset	384 }
a61af66fc99e Initial load duke parents: diff changeset	385
a61af66fc99e Initial load duke parents: diff changeset	386 // RedefineClasses() API support:
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	387 Symbol* klass_at_noresolve(int which) { return klass_name_at(which); }
0 a61af66fc99e Initial load duke parents: diff changeset	388
a61af66fc99e Initial load duke parents: diff changeset	389 jint int_at(int which) {
a61af66fc99e Initial load duke parents: diff changeset	390 assert(tag_at(which).is_int(), "Corrupted constant pool");
a61af66fc99e Initial load duke parents: diff changeset	391 return *int_at_addr(which);
a61af66fc99e Initial load duke parents: diff changeset	392 }
a61af66fc99e Initial load duke parents: diff changeset	393
a61af66fc99e Initial load duke parents: diff changeset	394 jlong long_at(int which) {
a61af66fc99e Initial load duke parents: diff changeset	395 assert(tag_at(which).is_long(), "Corrupted constant pool");
a61af66fc99e Initial load duke parents: diff changeset	396 // return *long_at_addr(which);
a61af66fc99e Initial load duke parents: diff changeset	397 u8 tmp = Bytes::get_native_u8((address)&base()[which]);
a61af66fc99e Initial load duke parents: diff changeset	398 return ((jlong)&tmp);
a61af66fc99e Initial load duke parents: diff changeset	399 }
a61af66fc99e Initial load duke parents: diff changeset	400
a61af66fc99e Initial load duke parents: diff changeset	401 jfloat float_at(int which) {
a61af66fc99e Initial load duke parents: diff changeset	402 assert(tag_at(which).is_float(), "Corrupted constant pool");
a61af66fc99e Initial load duke parents: diff changeset	403 return *float_at_addr(which);
a61af66fc99e Initial load duke parents: diff changeset	404 }
a61af66fc99e Initial load duke parents: diff changeset	405
a61af66fc99e Initial load duke parents: diff changeset	406 jdouble double_at(int which) {
a61af66fc99e Initial load duke parents: diff changeset	407 assert(tag_at(which).is_double(), "Corrupted constant pool");
a61af66fc99e Initial load duke parents: diff changeset	408 u8 tmp = Bytes::get_native_u8((address)&base()[which]);
a61af66fc99e Initial load duke parents: diff changeset	409 return ((jdouble)&tmp);
a61af66fc99e Initial load duke parents: diff changeset	410 }
a61af66fc99e Initial load duke parents: diff changeset	411
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	412 Symbol* symbol_at(int which) {
0 a61af66fc99e Initial load duke parents: diff changeset	413 assert(tag_at(which).is_utf8(), "Corrupted constant pool");
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	414 return slot_at(which).get_symbol();
0 a61af66fc99e Initial load duke parents: diff changeset	415 }
a61af66fc99e Initial load duke parents: diff changeset	416
a61af66fc99e Initial load duke parents: diff changeset	417 oop string_at(int which, TRAPS) {
a61af66fc99e Initial load duke parents: diff changeset	418 constantPoolHandle h_this(THREAD, this);
a61af66fc99e Initial load duke parents: diff changeset	419 return string_at_impl(h_this, which, CHECK_NULL);
a61af66fc99e Initial load duke parents: diff changeset	420 }
a61af66fc99e Initial load duke parents: diff changeset	421
1138 dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1059 diff changeset	422 oop object_at(int which) {
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1059 diff changeset	423 assert(tag_at(which).is_object(), "Corrupted constant pool");
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	424 return slot_at(which).get_oop();
1138 dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1059 diff changeset	425 }
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1059 diff changeset	426
431 a45484ea312d 6653858: dynamic languages need to be able to load anonymous classes jrose parents: 196 diff changeset	427 // A "pseudo-string" is an non-string oop that has found is way into
a45484ea312d 6653858: dynamic languages need to be able to load anonymous classes jrose parents: 196 diff changeset	428 // a String entry.
2416 38fea01eb669 6817525: turn on method handle functionality by default for JSR 292 twisti parents: 2192 diff changeset	429 // Under EnableInvokeDynamic this can happen if the user patches a live
431 a45484ea312d 6653858: dynamic languages need to be able to load anonymous classes jrose parents: 196 diff changeset	430 // object into a CONSTANT_String entry of an anonymous class.
a45484ea312d 6653858: dynamic languages need to be able to load anonymous classes jrose parents: 196 diff changeset	431 // Method oops internally created for method handles may also
a45484ea312d 6653858: dynamic languages need to be able to load anonymous classes jrose parents: 196 diff changeset	432 // use pseudo-strings to link themselves to related metaobjects.
a45484ea312d 6653858: dynamic languages need to be able to load anonymous classes jrose parents: 196 diff changeset	433
a45484ea312d 6653858: dynamic languages need to be able to load anonymous classes jrose parents: 196 diff changeset	434 bool is_pseudo_string_at(int which);
a45484ea312d 6653858: dynamic languages need to be able to load anonymous classes jrose parents: 196 diff changeset	435
a45484ea312d 6653858: dynamic languages need to be able to load anonymous classes jrose parents: 196 diff changeset	436 oop pseudo_string_at(int which) {
a45484ea312d 6653858: dynamic languages need to be able to load anonymous classes jrose parents: 196 diff changeset	437 assert(tag_at(which).is_string(), "Corrupted constant pool");
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	438 return slot_at(which).get_oop();
431 a45484ea312d 6653858: dynamic languages need to be able to load anonymous classes jrose parents: 196 diff changeset	439 }
a45484ea312d 6653858: dynamic languages need to be able to load anonymous classes jrose parents: 196 diff changeset	440
a45484ea312d 6653858: dynamic languages need to be able to load anonymous classes jrose parents: 196 diff changeset	441 void pseudo_string_at_put(int which, oop x) {
2416 38fea01eb669 6817525: turn on method handle functionality by default for JSR 292 twisti parents: 2192 diff changeset	442 assert(EnableInvokeDynamic, "");
431 a45484ea312d 6653858: dynamic languages need to be able to load anonymous classes jrose parents: 196 diff changeset	443 set_pseudo_string(); // mark header
a45484ea312d 6653858: dynamic languages need to be able to load anonymous classes jrose parents: 196 diff changeset	444 assert(tag_at(which).is_string() \|\| tag_at(which).is_unresolved_string(), "Corrupted constant pool");
a45484ea312d 6653858: dynamic languages need to be able to load anonymous classes jrose parents: 196 diff changeset	445 string_at_put(which, x); // this works just fine
a45484ea312d 6653858: dynamic languages need to be able to load anonymous classes jrose parents: 196 diff changeset	446 }
a45484ea312d 6653858: dynamic languages need to be able to load anonymous classes jrose parents: 196 diff changeset	447
0 a61af66fc99e Initial load duke parents: diff changeset	448 // only called when we are sure a string entry is already resolved (via an
a61af66fc99e Initial load duke parents: diff changeset	449 // earlier string_at call.
a61af66fc99e Initial load duke parents: diff changeset	450 oop resolved_string_at(int which) {
a61af66fc99e Initial load duke parents: diff changeset	451 assert(tag_at(which).is_string(), "Corrupted constant pool");
a61af66fc99e Initial load duke parents: diff changeset	452 // Must do an acquire here in case another thread resolved the klass
a61af66fc99e Initial load duke parents: diff changeset	453 // behind our back, lest we later load stale values thru the oop.
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	454 return CPSlot(OrderAccess::load_ptr_acquire(obj_at_addr_raw(which))).get_oop();
0 a61af66fc99e Initial load duke parents: diff changeset	455 }
a61af66fc99e Initial load duke parents: diff changeset	456
a61af66fc99e Initial load duke parents: diff changeset	457 // This method should only be used with a cpool lock or during parsing or gc
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	458 Symbol* unresolved_string_at(int which) { // Temporary until actual use
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	459 Symbol* s = CPSlot(OrderAccess::load_ptr_acquire(obj_at_addr_raw(which))).get_symbol();
0 a61af66fc99e Initial load duke parents: diff changeset	460 // check that the string is still unresolved.
a61af66fc99e Initial load duke parents: diff changeset	461 assert(tag_at(which).is_unresolved_string(), "Corrupted constant pool");
a61af66fc99e Initial load duke parents: diff changeset	462 return s;
a61af66fc99e Initial load duke parents: diff changeset	463 }
a61af66fc99e Initial load duke parents: diff changeset	464
a61af66fc99e Initial load duke parents: diff changeset	465 // Returns an UTF8 for a CONSTANT_String entry at a given index.
a61af66fc99e Initial load duke parents: diff changeset	466 // UTF8 char* representation was chosen to avoid conversion of
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	467 // java_lang_Strings at resolved entries into Symbol*s
0 a61af66fc99e Initial load duke parents: diff changeset	468 // or vice versa.
431 a45484ea312d 6653858: dynamic languages need to be able to load anonymous classes jrose parents: 196 diff changeset	469 // Caller is responsible for checking for pseudo-strings.
0 a61af66fc99e Initial load duke parents: diff changeset	470 char* string_at_noresolve(int which);
a61af66fc99e Initial load duke parents: diff changeset	471
a61af66fc99e Initial load duke parents: diff changeset	472 jint name_and_type_at(int which) {
a61af66fc99e Initial load duke parents: diff changeset	473 assert(tag_at(which).is_name_and_type(), "Corrupted constant pool");
a61af66fc99e Initial load duke parents: diff changeset	474 return *int_at_addr(which);
a61af66fc99e Initial load duke parents: diff changeset	475 }
a61af66fc99e Initial load duke parents: diff changeset	476
1602 136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	477 int method_handle_ref_kind_at(int which) {
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	478 assert(tag_at(which).is_method_handle(), "Corrupted constant pool");
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	479 return extract_low_short_from_int(*int_at_addr(which)); // mask out unwanted ref_index bits
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	480 }
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	481 int method_handle_index_at(int which) {
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	482 assert(tag_at(which).is_method_handle(), "Corrupted constant pool");
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	483 return extract_high_short_from_int(*int_at_addr(which)); // shift out unwanted ref_kind bits
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	484 }
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	485 int method_type_index_at(int which) {
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	486 assert(tag_at(which).is_method_type(), "Corrupted constant pool");
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	487 return *int_at_addr(which);
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	488 }
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	489 // Derived queries:
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	490 Symbol* method_handle_name_ref_at(int which) {
1602 136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	491 int member = method_handle_index_at(which);
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	492 return impl_name_ref_at(member, true);
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	493 }
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	494 Symbol* method_handle_signature_ref_at(int which) {
1602 136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	495 int member = method_handle_index_at(which);
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	496 return impl_signature_ref_at(member, true);
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	497 }
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	498 int method_handle_klass_index_at(int which) {
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	499 int member = method_handle_index_at(which);
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	500 return impl_klass_ref_index_at(member, true);
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	501 }
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	502 Symbol* method_type_signature_at(int which) {
1602 136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	503 int sym = method_type_index_at(which);
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	504 return symbol_at(sym);
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	505 }
1913 3b2dea75431e 6984311: JSR 292 needs optional bootstrap method parameters jrose parents: 1910 diff changeset	506
2011 dad31fc330cd 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute jrose parents: 1972 diff changeset	507 int invoke_dynamic_name_and_type_ref_index_at(int which) {
1913 3b2dea75431e 6984311: JSR 292 needs optional bootstrap method parameters jrose parents: 1910 diff changeset	508 assert(tag_at(which).is_invoke_dynamic(), "Corrupted constant pool");
2011 dad31fc330cd 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute jrose parents: 1972 diff changeset	509 return extract_high_short_from_int(*int_at_addr(which));
1913 3b2dea75431e 6984311: JSR 292 needs optional bootstrap method parameters jrose parents: 1910 diff changeset	510 }
2011 dad31fc330cd 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute jrose parents: 1972 diff changeset	511 int invoke_dynamic_bootstrap_specifier_index(int which) {
dad31fc330cd 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute jrose parents: 1972 diff changeset	512 assert(tag_at(which).value() == JVM_CONSTANT_InvokeDynamic, "Corrupted constant pool");
dad31fc330cd 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute jrose parents: 1972 diff changeset	513 return extract_low_short_from_int(*int_at_addr(which));
dad31fc330cd 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute jrose parents: 1972 diff changeset	514 }
dad31fc330cd 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute jrose parents: 1972 diff changeset	515 int invoke_dynamic_operand_base(int which) {
dad31fc330cd 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute jrose parents: 1972 diff changeset	516 int bootstrap_specifier_index = invoke_dynamic_bootstrap_specifier_index(which);
dad31fc330cd 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute jrose parents: 1972 diff changeset	517 return operand_offset_at(operands(), bootstrap_specifier_index);
1913 3b2dea75431e 6984311: JSR 292 needs optional bootstrap method parameters jrose parents: 1910 diff changeset	518 }
2011 dad31fc330cd 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute jrose parents: 1972 diff changeset	519 // The first part of the operands array consists of an index into the second part.
dad31fc330cd 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute jrose parents: 1972 diff changeset	520 // Extract a 32-bit index value from the first part.
dad31fc330cd 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute jrose parents: 1972 diff changeset	521 static int operand_offset_at(typeArrayOop operands, int bootstrap_specifier_index) {
dad31fc330cd 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute jrose parents: 1972 diff changeset	522 int n = (bootstrap_specifier_index * 2);
dad31fc330cd 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute jrose parents: 1972 diff changeset	523 assert(n >= 0 && n+2 <= operands->length(), "oob");
dad31fc330cd 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute jrose parents: 1972 diff changeset	524 // The first 32-bit index points to the beginning of the second part
dad31fc330cd 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute jrose parents: 1972 diff changeset	525 // of the operands array. Make sure this index is in the first part.
dad31fc330cd 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute jrose parents: 1972 diff changeset	526 DEBUG_ONLY(int second_part = build_int_from_shorts(operands->short_at(0),
dad31fc330cd 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute jrose parents: 1972 diff changeset	527 operands->short_at(1)));
dad31fc330cd 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute jrose parents: 1972 diff changeset	528 assert(second_part == 0 \|\| n+2 <= second_part, "oob (2)");
dad31fc330cd 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute jrose parents: 1972 diff changeset	529 int offset = build_int_from_shorts(operands->short_at(n+0),
dad31fc330cd 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute jrose parents: 1972 diff changeset	530 operands->short_at(n+1));
dad31fc330cd 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute jrose parents: 1972 diff changeset	531 // The offset itself must point into the second part of the array.
dad31fc330cd 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute jrose parents: 1972 diff changeset	532 assert(offset == 0 \|\| offset >= second_part && offset <= operands->length(), "oob (3)");
dad31fc330cd 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute jrose parents: 1972 diff changeset	533 return offset;
1913 3b2dea75431e 6984311: JSR 292 needs optional bootstrap method parameters jrose parents: 1910 diff changeset	534 }
2011 dad31fc330cd 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute jrose parents: 1972 diff changeset	535 static void operand_offset_at_put(typeArrayOop operands, int bootstrap_specifier_index, int offset) {
dad31fc330cd 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute jrose parents: 1972 diff changeset	536 int n = bootstrap_specifier_index * 2;
dad31fc330cd 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute jrose parents: 1972 diff changeset	537 assert(n >= 0 && n+2 <= operands->length(), "oob");
dad31fc330cd 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute jrose parents: 1972 diff changeset	538 operands->short_at_put(n+0, extract_low_short_from_int(offset));
dad31fc330cd 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute jrose parents: 1972 diff changeset	539 operands->short_at_put(n+1, extract_high_short_from_int(offset));
dad31fc330cd 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute jrose parents: 1972 diff changeset	540 }
dad31fc330cd 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute jrose parents: 1972 diff changeset	541 static int operand_array_length(typeArrayOop operands) {
dad31fc330cd 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute jrose parents: 1972 diff changeset	542 if (operands == NULL \|\| operands->length() == 0) return 0;
dad31fc330cd 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute jrose parents: 1972 diff changeset	543 int second_part = operand_offset_at(operands, 0);
dad31fc330cd 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute jrose parents: 1972 diff changeset	544 return (second_part / 2);
1913 3b2dea75431e 6984311: JSR 292 needs optional bootstrap method parameters jrose parents: 1910 diff changeset	545 }
3b2dea75431e 6984311: JSR 292 needs optional bootstrap method parameters jrose parents: 1910 diff changeset	546
2011 dad31fc330cd 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute jrose parents: 1972 diff changeset	547 #ifdef ASSERT
dad31fc330cd 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute jrose parents: 1972 diff changeset	548 // operand tuples fit together exactly, end to end
dad31fc330cd 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute jrose parents: 1972 diff changeset	549 static int operand_limit_at(typeArrayOop operands, int bootstrap_specifier_index) {
dad31fc330cd 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute jrose parents: 1972 diff changeset	550 int nextidx = bootstrap_specifier_index + 1;
dad31fc330cd 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute jrose parents: 1972 diff changeset	551 if (nextidx == operand_array_length(operands))
dad31fc330cd 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute jrose parents: 1972 diff changeset	552 return operands->length();
dad31fc330cd 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute jrose parents: 1972 diff changeset	553 else
dad31fc330cd 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute jrose parents: 1972 diff changeset	554 return operand_offset_at(operands, nextidx);
dad31fc330cd 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute jrose parents: 1972 diff changeset	555 }
dad31fc330cd 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute jrose parents: 1972 diff changeset	556 int invoke_dynamic_operand_limit(int which) {
dad31fc330cd 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute jrose parents: 1972 diff changeset	557 int bootstrap_specifier_index = invoke_dynamic_bootstrap_specifier_index(which);
dad31fc330cd 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute jrose parents: 1972 diff changeset	558 return operand_limit_at(operands(), bootstrap_specifier_index);
dad31fc330cd 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute jrose parents: 1972 diff changeset	559 }
dad31fc330cd 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute jrose parents: 1972 diff changeset	560 #endif //ASSERT
dad31fc330cd 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute jrose parents: 1972 diff changeset	561
dad31fc330cd 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute jrose parents: 1972 diff changeset	562 // layout of InvokeDynamic bootstrap method specifier (in second part of operands array):
1913 3b2dea75431e 6984311: JSR 292 needs optional bootstrap method parameters jrose parents: 1910 diff changeset	563 enum {
3b2dea75431e 6984311: JSR 292 needs optional bootstrap method parameters jrose parents: 1910 diff changeset	564 _indy_bsm_offset = 0, // CONSTANT_MethodHandle bsm
2011 dad31fc330cd 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute jrose parents: 1972 diff changeset	565 _indy_argc_offset = 1, // u2 argc
dad31fc330cd 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute jrose parents: 1972 diff changeset	566 _indy_argv_offset = 2 // u2 argv[argc]
1913 3b2dea75431e 6984311: JSR 292 needs optional bootstrap method parameters jrose parents: 1910 diff changeset	567 };
1660 083fde3b838e 6964498: JSR 292 invokedynamic sites need local bootstrap methods jrose parents: 1602 diff changeset	568 int invoke_dynamic_bootstrap_method_ref_index_at(int which) {
083fde3b838e 6964498: JSR 292 invokedynamic sites need local bootstrap methods jrose parents: 1602 diff changeset	569 assert(tag_at(which).is_invoke_dynamic(), "Corrupted constant pool");
2011 dad31fc330cd 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute jrose parents: 1972 diff changeset	570 int op_base = invoke_dynamic_operand_base(which);
dad31fc330cd 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute jrose parents: 1972 diff changeset	571 return operands()->short_at(op_base + _indy_bsm_offset);
1913 3b2dea75431e 6984311: JSR 292 needs optional bootstrap method parameters jrose parents: 1910 diff changeset	572 }
3b2dea75431e 6984311: JSR 292 needs optional bootstrap method parameters jrose parents: 1910 diff changeset	573 int invoke_dynamic_argument_count_at(int which) {
3b2dea75431e 6984311: JSR 292 needs optional bootstrap method parameters jrose parents: 1910 diff changeset	574 assert(tag_at(which).is_invoke_dynamic(), "Corrupted constant pool");
2011 dad31fc330cd 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute jrose parents: 1972 diff changeset	575 int op_base = invoke_dynamic_operand_base(which);
dad31fc330cd 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute jrose parents: 1972 diff changeset	576 int argc = operands()->short_at(op_base + _indy_argc_offset);
dad31fc330cd 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute jrose parents: 1972 diff changeset	577 DEBUG_ONLY(int end_offset = op_base + _indy_argv_offset + argc;
dad31fc330cd 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute jrose parents: 1972 diff changeset	578 int next_offset = invoke_dynamic_operand_limit(which));
dad31fc330cd 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute jrose parents: 1972 diff changeset	579 assert(end_offset == next_offset, "matched ending");
1913 3b2dea75431e 6984311: JSR 292 needs optional bootstrap method parameters jrose parents: 1910 diff changeset	580 return argc;
3b2dea75431e 6984311: JSR 292 needs optional bootstrap method parameters jrose parents: 1910 diff changeset	581 }
3b2dea75431e 6984311: JSR 292 needs optional bootstrap method parameters jrose parents: 1910 diff changeset	582 int invoke_dynamic_argument_index_at(int which, int j) {
2011 dad31fc330cd 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute jrose parents: 1972 diff changeset	583 int op_base = invoke_dynamic_operand_base(which);
dad31fc330cd 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute jrose parents: 1972 diff changeset	584 DEBUG_ONLY(int argc = operands()->short_at(op_base + _indy_argc_offset));
dad31fc330cd 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute jrose parents: 1972 diff changeset	585 assert((uint)j < (uint)argc, "oob");
dad31fc330cd 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute jrose parents: 1972 diff changeset	586 return operands()->short_at(op_base + _indy_argv_offset + j);
1660 083fde3b838e 6964498: JSR 292 invokedynamic sites need local bootstrap methods jrose parents: 1602 diff changeset	587 }
1602 136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	588
726 be93aad57795 6655646: dynamic languages need dynamically linked call sites jrose parents: 579 diff changeset	589 // The following methods (name/signature/klass_ref_at, klass_ref_at_noresolve,
1059 389049f3f393 6858164: invokedynamic code needs some cleanup (post-6655638) jrose parents: 726 diff changeset	590 // name_and_type_ref_index_at) all expect to be passed indices obtained
1910 d1896d1dda3e 6981788: GC map generator sometimes picks up the wrong kind of instruction operand jrose parents: 1660 diff changeset	591 // directly from the bytecode.
1059 389049f3f393 6858164: invokedynamic code needs some cleanup (post-6655638) jrose parents: 726 diff changeset	592 // If the indices are meant to refer to fields or methods, they are
1910 d1896d1dda3e 6981788: GC map generator sometimes picks up the wrong kind of instruction operand jrose parents: 1660 diff changeset	593 // actually rewritten constant pool cache indices.
1059 389049f3f393 6858164: invokedynamic code needs some cleanup (post-6655638) jrose parents: 726 diff changeset	594 // The routine remap_instruction_operand_from_cache manages the adjustment
389049f3f393 6858164: invokedynamic code needs some cleanup (post-6655638) jrose parents: 726 diff changeset	595 // of these values back to constant pool indices.
726 be93aad57795 6655646: dynamic languages need dynamically linked call sites jrose parents: 579 diff changeset	596
1059 389049f3f393 6858164: invokedynamic code needs some cleanup (post-6655638) jrose parents: 726 diff changeset	597 // There are also "uncached" versions which do not adjust the operand index; see below.
0 a61af66fc99e Initial load duke parents: diff changeset	598
1910 d1896d1dda3e 6981788: GC map generator sometimes picks up the wrong kind of instruction operand jrose parents: 1660 diff changeset	599 // FIXME: Consider renaming these with a prefix "cached_" to make the distinction clear.
d1896d1dda3e 6981788: GC map generator sometimes picks up the wrong kind of instruction operand jrose parents: 1660 diff changeset	600 // In a few cases (the verifier) there are uses before a cpcache has been built,
d1896d1dda3e 6981788: GC map generator sometimes picks up the wrong kind of instruction operand jrose parents: 1660 diff changeset	601 // which are handled by a dynamic check in remap_instruction_operand_from_cache.
d1896d1dda3e 6981788: GC map generator sometimes picks up the wrong kind of instruction operand jrose parents: 1660 diff changeset	602 // FIXME: Remove the dynamic check, and adjust all callers to specify the correct mode.
d1896d1dda3e 6981788: GC map generator sometimes picks up the wrong kind of instruction operand jrose parents: 1660 diff changeset	603
0 a61af66fc99e Initial load duke parents: diff changeset	604 // Lookup for entries consisting of (klass_index, name_and_type index)
a61af66fc99e Initial load duke parents: diff changeset	605 klassOop klass_ref_at(int which, TRAPS);
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	606 Symbol* klass_ref_at_noresolve(int which);
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	607 Symbol* name_ref_at(int which) { return impl_name_ref_at(which, false); }
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	608 Symbol* signature_ref_at(int which) { return impl_signature_ref_at(which, false); }
0 a61af66fc99e Initial load duke parents: diff changeset	609
726 be93aad57795 6655646: dynamic languages need dynamically linked call sites jrose parents: 579 diff changeset	610 int klass_ref_index_at(int which) { return impl_klass_ref_index_at(which, false); }
be93aad57795 6655646: dynamic languages need dynamically linked call sites jrose parents: 579 diff changeset	611 int name_and_type_ref_index_at(int which) { return impl_name_and_type_ref_index_at(which, false); }
0 a61af66fc99e Initial load duke parents: diff changeset	612
a61af66fc99e Initial load duke parents: diff changeset	613 // Lookup for entries consisting of (name_index, signature_index)
726 be93aad57795 6655646: dynamic languages need dynamically linked call sites jrose parents: 579 diff changeset	614 int name_ref_index_at(int which_nt); // == low-order jshort of name_and_type_at(which_nt)
be93aad57795 6655646: dynamic languages need dynamically linked call sites jrose parents: 579 diff changeset	615 int signature_ref_index_at(int which_nt); // == high-order jshort of name_and_type_at(which_nt)
0 a61af66fc99e Initial load duke parents: diff changeset	616
a61af66fc99e Initial load duke parents: diff changeset	617 BasicType basic_type_for_signature_at(int which);
a61af66fc99e Initial load duke parents: diff changeset	618
a61af66fc99e Initial load duke parents: diff changeset	619 // Resolve string constants (to prevent allocation during compilation)
a61af66fc99e Initial load duke parents: diff changeset	620 void resolve_string_constants(TRAPS) {
a61af66fc99e Initial load duke parents: diff changeset	621 constantPoolHandle h_this(THREAD, this);
a61af66fc99e Initial load duke parents: diff changeset	622 resolve_string_constants_impl(h_this, CHECK);
a61af66fc99e Initial load duke parents: diff changeset	623 }
a61af66fc99e Initial load duke parents: diff changeset	624
1913 3b2dea75431e 6984311: JSR 292 needs optional bootstrap method parameters jrose parents: 1910 diff changeset	625 private:
3b2dea75431e 6984311: JSR 292 needs optional bootstrap method parameters jrose parents: 1910 diff changeset	626 enum { _no_index_sentinel = -1, _possible_index_sentinel = -2 };
3b2dea75431e 6984311: JSR 292 needs optional bootstrap method parameters jrose parents: 1910 diff changeset	627 public:
3b2dea75431e 6984311: JSR 292 needs optional bootstrap method parameters jrose parents: 1910 diff changeset	628
1602 136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	629 // Resolve late bound constants.
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	630 oop resolve_constant_at(int index, TRAPS) {
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	631 constantPoolHandle h_this(THREAD, this);
1913 3b2dea75431e 6984311: JSR 292 needs optional bootstrap method parameters jrose parents: 1910 diff changeset	632 return resolve_constant_at_impl(h_this, index, _no_index_sentinel, THREAD);
1602 136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	633 }
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	634
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	635 oop resolve_cached_constant_at(int cache_index, TRAPS) {
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	636 constantPoolHandle h_this(THREAD, this);
1913 3b2dea75431e 6984311: JSR 292 needs optional bootstrap method parameters jrose parents: 1910 diff changeset	637 return resolve_constant_at_impl(h_this, _no_index_sentinel, cache_index, THREAD);
3b2dea75431e 6984311: JSR 292 needs optional bootstrap method parameters jrose parents: 1910 diff changeset	638 }
3b2dea75431e 6984311: JSR 292 needs optional bootstrap method parameters jrose parents: 1910 diff changeset	639
3b2dea75431e 6984311: JSR 292 needs optional bootstrap method parameters jrose parents: 1910 diff changeset	640 oop resolve_possibly_cached_constant_at(int pool_index, TRAPS) {
3b2dea75431e 6984311: JSR 292 needs optional bootstrap method parameters jrose parents: 1910 diff changeset	641 constantPoolHandle h_this(THREAD, this);
3b2dea75431e 6984311: JSR 292 needs optional bootstrap method parameters jrose parents: 1910 diff changeset	642 return resolve_constant_at_impl(h_this, pool_index, _possible_index_sentinel, THREAD);
1602 136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	643 }
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	644
0 a61af66fc99e Initial load duke parents: diff changeset	645 // Klass name matches name at offset
a61af66fc99e Initial load duke parents: diff changeset	646 bool klass_name_at_matches(instanceKlassHandle k, int which);
a61af66fc99e Initial load duke parents: diff changeset	647
a61af66fc99e Initial load duke parents: diff changeset	648 // Sizing
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	649 int length() const { return _length; }
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	650 void set_length(int length) { _length = length; }
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	651
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	652 // Tells whether index is within bounds.
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	653 bool is_within_bounds(int index) const {
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	654 return 0 <= index && index < length();
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	655 }
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	656
0 a61af66fc99e Initial load duke parents: diff changeset	657 static int header_size() { return sizeof(constantPoolOopDesc)/HeapWordSize; }
a61af66fc99e Initial load duke parents: diff changeset	658 static int object_size(int length) { return align_object_size(header_size() + length); }
a61af66fc99e Initial load duke parents: diff changeset	659 int object_size() { return object_size(length()); }
a61af66fc99e Initial load duke parents: diff changeset	660
518 0af8b0718fc9 6692899: CMS: many vm.parallel_class_loading tests fail with assert "missing Printezis mark" jmasa parents: 431 diff changeset	661 bool is_conc_safe() { return _is_conc_safe; }
0af8b0718fc9 6692899: CMS: many vm.parallel_class_loading tests fail with assert "missing Printezis mark" jmasa parents: 431 diff changeset	662 void set_is_conc_safe(bool v) { _is_conc_safe = v; }
0af8b0718fc9 6692899: CMS: many vm.parallel_class_loading tests fail with assert "missing Printezis mark" jmasa parents: 431 diff changeset	663
0 a61af66fc99e Initial load duke parents: diff changeset	664 friend class constantPoolKlass;
a61af66fc99e Initial load duke parents: diff changeset	665 friend class ClassFileParser;
a61af66fc99e Initial load duke parents: diff changeset	666 friend class SystemDictionary;
a61af66fc99e Initial load duke parents: diff changeset	667
a61af66fc99e Initial load duke parents: diff changeset	668 // Used by compiler to prevent classloading.
3461 81d815b05abb 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 2460 diff changeset	669 static methodOop method_at_if_loaded (constantPoolHandle this_oop, int which,
81d815b05abb 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 2460 diff changeset	670 Bytecodes::Code bc = Bytecodes::_illegal);
0 a61af66fc99e Initial load duke parents: diff changeset	671 static klassOop klass_at_if_loaded (constantPoolHandle this_oop, int which);
a61af66fc99e Initial load duke parents: diff changeset	672 static klassOop klass_ref_at_if_loaded (constantPoolHandle this_oop, int which);
a61af66fc99e Initial load duke parents: diff changeset	673 // Same as above - but does LinkResolving.
a61af66fc99e Initial load duke parents: diff changeset	674 static klassOop klass_ref_at_if_loaded_check(constantPoolHandle this_oop, int which, TRAPS);
a61af66fc99e Initial load duke parents: diff changeset	675
a61af66fc99e Initial load duke parents: diff changeset	676 // Routines currently used for annotations (only called by jvm.cpp) but which might be used in the
1910 d1896d1dda3e 6981788: GC map generator sometimes picks up the wrong kind of instruction operand jrose parents: 1660 diff changeset	677 // future by other Java code. These take constant pool indices rather than
0 a61af66fc99e Initial load duke parents: diff changeset	678 // constant pool cache indices as do the peer methods above.
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	679 Symbol* uncached_klass_ref_at_noresolve(int which);
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	680 Symbol* uncached_name_ref_at(int which) { return impl_name_ref_at(which, true); }
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	681 Symbol* uncached_signature_ref_at(int which) { return impl_signature_ref_at(which, true); }
726 be93aad57795 6655646: dynamic languages need dynamically linked call sites jrose parents: 579 diff changeset	682 int uncached_klass_ref_index_at(int which) { return impl_klass_ref_index_at(which, true); }
be93aad57795 6655646: dynamic languages need dynamically linked call sites jrose parents: 579 diff changeset	683 int uncached_name_and_type_ref_index_at(int which) { return impl_name_and_type_ref_index_at(which, true); }
0 a61af66fc99e Initial load duke parents: diff changeset	684
a61af66fc99e Initial load duke parents: diff changeset	685 // Sharing
a61af66fc99e Initial load duke parents: diff changeset	686 int pre_resolve_shared_klasses(TRAPS);
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	687 void shared_symbols_iterate(SymbolClosure* closure0);
0 a61af66fc99e Initial load duke parents: diff changeset	688 void shared_tags_iterate(OopClosure* closure0);
a61af66fc99e Initial load duke parents: diff changeset	689 void shared_strings_iterate(OopClosure* closure0);
a61af66fc99e Initial load duke parents: diff changeset	690
a61af66fc99e Initial load duke parents: diff changeset	691 // Debugging
a61af66fc99e Initial load duke parents: diff changeset	692 const char* printable_name_at(int which) PRODUCT_RETURN0;
a61af66fc99e Initial load duke parents: diff changeset	693
1565 ab102d5d923e 6939207: refactor constant pool index processing jrose parents: 1138 diff changeset	694 #ifdef ASSERT
ab102d5d923e 6939207: refactor constant pool index processing jrose parents: 1138 diff changeset	695 enum { CPCACHE_INDEX_TAG = 0x10000 }; // helps keep CP cache indices distinct from CP indices
1602 136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	696 #else
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	697 enum { CPCACHE_INDEX_TAG = 0 }; // in product mode, this zero value is a no-op
1565 ab102d5d923e 6939207: refactor constant pool index processing jrose parents: 1138 diff changeset	698 #endif //ASSERT
ab102d5d923e 6939207: refactor constant pool index processing jrose parents: 1138 diff changeset	699
0 a61af66fc99e Initial load duke parents: diff changeset	700 private:
a61af66fc99e Initial load duke parents: diff changeset	701
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	702 Symbol* impl_name_ref_at(int which, bool uncached);
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	703 Symbol* impl_signature_ref_at(int which, bool uncached);
726 be93aad57795 6655646: dynamic languages need dynamically linked call sites jrose parents: 579 diff changeset	704 int impl_klass_ref_index_at(int which, bool uncached);
be93aad57795 6655646: dynamic languages need dynamically linked call sites jrose parents: 579 diff changeset	705 int impl_name_and_type_ref_index_at(int which, bool uncached);
be93aad57795 6655646: dynamic languages need dynamically linked call sites jrose parents: 579 diff changeset	706
3577 96c40b338c1a Added new method that loads and initializes a class that is referenced by a cp entry. Thomas Wuerthinger <thomas.wuerthinger@oracle.com> parents: 3461 diff changeset	707 public:
1565 ab102d5d923e 6939207: refactor constant pool index processing jrose parents: 1138 diff changeset	708 int remap_instruction_operand_from_cache(int operand); // operand must be biased by CPCACHE_INDEX_TAG
0 a61af66fc99e Initial load duke parents: diff changeset	709
3577 96c40b338c1a Added new method that loads and initializes a class that is referenced by a cp entry. Thomas Wuerthinger <thomas.wuerthinger@oracle.com> parents: 3461 diff changeset	710 private:
0 a61af66fc99e Initial load duke parents: diff changeset	711 // Used while constructing constant pool (only by ClassFileParser)
a61af66fc99e Initial load duke parents: diff changeset	712 jint klass_index_at(int which) {
a61af66fc99e Initial load duke parents: diff changeset	713 assert(tag_at(which).is_klass_index(), "Corrupted constant pool");
a61af66fc99e Initial load duke parents: diff changeset	714 return *int_at_addr(which);
a61af66fc99e Initial load duke parents: diff changeset	715 }
a61af66fc99e Initial load duke parents: diff changeset	716
a61af66fc99e Initial load duke parents: diff changeset	717 jint string_index_at(int which) {
a61af66fc99e Initial load duke parents: diff changeset	718 assert(tag_at(which).is_string_index(), "Corrupted constant pool");
a61af66fc99e Initial load duke parents: diff changeset	719 return *int_at_addr(which);
a61af66fc99e Initial load duke parents: diff changeset	720 }
a61af66fc99e Initial load duke parents: diff changeset	721
a61af66fc99e Initial load duke parents: diff changeset	722 // Performs the LinkResolver checks
a61af66fc99e Initial load duke parents: diff changeset	723 static void verify_constant_pool_resolve(constantPoolHandle this_oop, KlassHandle klass, TRAPS);
a61af66fc99e Initial load duke parents: diff changeset	724
a61af66fc99e Initial load duke parents: diff changeset	725 // Implementation of methods that needs an exposed 'this' pointer, in order to
a61af66fc99e Initial load duke parents: diff changeset	726 // handle GC while executing the method
a61af66fc99e Initial load duke parents: diff changeset	727 static klassOop klass_at_impl(constantPoolHandle this_oop, int which, TRAPS);
a61af66fc99e Initial load duke parents: diff changeset	728 static oop string_at_impl(constantPoolHandle this_oop, int which, TRAPS);
a61af66fc99e Initial load duke parents: diff changeset	729
a61af66fc99e Initial load duke parents: diff changeset	730 // Resolve string constants (to prevent allocation during compilation)
a61af66fc99e Initial load duke parents: diff changeset	731 static void resolve_string_constants_impl(constantPoolHandle this_oop, TRAPS);
a61af66fc99e Initial load duke parents: diff changeset	732
1602 136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	733 static oop resolve_constant_at_impl(constantPoolHandle this_oop, int index, int cache_index, TRAPS);
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	734
0 a61af66fc99e Initial load duke parents: diff changeset	735 public:
a61af66fc99e Initial load duke parents: diff changeset	736 // Merging constantPoolOop support:
a61af66fc99e Initial load duke parents: diff changeset	737 bool compare_entry_to(int index1, constantPoolHandle cp2, int index2, TRAPS);
2011 dad31fc330cd 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute jrose parents: 1972 diff changeset	738 void copy_cp_to(int start_i, int end_i, constantPoolHandle to_cp, int to_i, TRAPS) {
dad31fc330cd 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute jrose parents: 1972 diff changeset	739 constantPoolHandle h_this(THREAD, this);
dad31fc330cd 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute jrose parents: 1972 diff changeset	740 copy_cp_to_impl(h_this, start_i, end_i, to_cp, to_i, THREAD);
dad31fc330cd 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute jrose parents: 1972 diff changeset	741 }
dad31fc330cd 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute jrose parents: 1972 diff changeset	742 static void copy_cp_to_impl(constantPoolHandle from_cp, int start_i, int end_i, constantPoolHandle to_cp, int to_i, TRAPS);
dad31fc330cd 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute jrose parents: 1972 diff changeset	743 static void copy_entry_to(constantPoolHandle from_cp, int from_i, constantPoolHandle to_cp, int to_i, TRAPS);
0 a61af66fc99e Initial load duke parents: diff changeset	744 int find_matching_entry(int pattern_i, constantPoolHandle search_cp, TRAPS);
a61af66fc99e Initial load duke parents: diff changeset	745 int orig_length() const { return _orig_length; }
a61af66fc99e Initial load duke parents: diff changeset	746 void set_orig_length(int orig_length) { _orig_length = orig_length; }
a61af66fc99e Initial load duke parents: diff changeset	747
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	748 // Decrease ref counts of symbols that are in the constant pool
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	749 // when the holder class is unloaded
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	750 void unreference_symbols();
0 a61af66fc99e Initial load duke parents: diff changeset	751
a61af66fc99e Initial load duke parents: diff changeset	752 // JVMTI accesss - GetConstantPool, RetransformClasses, ...
a61af66fc99e Initial load duke parents: diff changeset	753 friend class JvmtiConstantPoolReconstituter;
a61af66fc99e Initial load duke parents: diff changeset	754
a61af66fc99e Initial load duke parents: diff changeset	755 private:
a61af66fc99e Initial load duke parents: diff changeset	756 jint cpool_entry_size(jint idx);
a61af66fc99e Initial load duke parents: diff changeset	757 jint hash_entries_to(SymbolHashMap symmap, SymbolHashMap classmap);
a61af66fc99e Initial load duke parents: diff changeset	758
a61af66fc99e Initial load duke parents: diff changeset	759 // Copy cpool bytes into byte array.
a61af66fc99e Initial load duke parents: diff changeset	760 // Returns:
a61af66fc99e Initial load duke parents: diff changeset	761 // int > 0, count of the raw cpool bytes that have been copied
a61af66fc99e Initial load duke parents: diff changeset	762 // 0, OutOfMemory error
a61af66fc99e Initial load duke parents: diff changeset	763 // -1, Internal error
a61af66fc99e Initial load duke parents: diff changeset	764 int copy_cpool_bytes(int cpool_size,
a61af66fc99e Initial load duke parents: diff changeset	765 SymbolHashMap* tbl,
a61af66fc99e Initial load duke parents: diff changeset	766 unsigned char *bytes);
a61af66fc99e Initial load duke parents: diff changeset	767 };
a61af66fc99e Initial load duke parents: diff changeset	768
a61af66fc99e Initial load duke parents: diff changeset	769 class SymbolHashMapEntry : public CHeapObj {
a61af66fc99e Initial load duke parents: diff changeset	770 private:
a61af66fc99e Initial load duke parents: diff changeset	771 unsigned int _hash; // 32-bit hash for item
a61af66fc99e Initial load duke parents: diff changeset	772 SymbolHashMapEntry* _next; // Next element in the linked list for this bucket
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	773 Symbol* _symbol; // 1-st part of the mapping: symbol => value
0 a61af66fc99e Initial load duke parents: diff changeset	774 u2 _value; // 2-nd part of the mapping: symbol => value
a61af66fc99e Initial load duke parents: diff changeset	775
a61af66fc99e Initial load duke parents: diff changeset	776 public:
a61af66fc99e Initial load duke parents: diff changeset	777 unsigned int hash() const { return _hash; }
a61af66fc99e Initial load duke parents: diff changeset	778 void set_hash(unsigned int hash) { _hash = hash; }
a61af66fc99e Initial load duke parents: diff changeset	779
a61af66fc99e Initial load duke parents: diff changeset	780 SymbolHashMapEntry* next() const { return _next; }
a61af66fc99e Initial load duke parents: diff changeset	781 void set_next(SymbolHashMapEntry* next) { _next = next; }
a61af66fc99e Initial load duke parents: diff changeset	782
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	783 Symbol* symbol() const { return _symbol; }
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	784 void set_symbol(Symbol* sym) { _symbol = sym; }
0 a61af66fc99e Initial load duke parents: diff changeset	785
a61af66fc99e Initial load duke parents: diff changeset	786 u2 value() const { return _value; }
a61af66fc99e Initial load duke parents: diff changeset	787 void set_value(u2 value) { _value = value; }
a61af66fc99e Initial load duke parents: diff changeset	788
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	789 SymbolHashMapEntry(unsigned int hash, Symbol* symbol, u2 value)
0 a61af66fc99e Initial load duke parents: diff changeset	790 : _hash(hash), _symbol(symbol), _value(value), _next(NULL) {}
a61af66fc99e Initial load duke parents: diff changeset	791
a61af66fc99e Initial load duke parents: diff changeset	792 }; // End SymbolHashMapEntry class
a61af66fc99e Initial load duke parents: diff changeset	793
a61af66fc99e Initial load duke parents: diff changeset	794
a61af66fc99e Initial load duke parents: diff changeset	795 class SymbolHashMapBucket : public CHeapObj {
a61af66fc99e Initial load duke parents: diff changeset	796
a61af66fc99e Initial load duke parents: diff changeset	797 private:
a61af66fc99e Initial load duke parents: diff changeset	798 SymbolHashMapEntry* _entry;
a61af66fc99e Initial load duke parents: diff changeset	799
a61af66fc99e Initial load duke parents: diff changeset	800 public:
a61af66fc99e Initial load duke parents: diff changeset	801 SymbolHashMapEntry* entry() const { return _entry; }
a61af66fc99e Initial load duke parents: diff changeset	802 void set_entry(SymbolHashMapEntry* entry) { _entry = entry; }
a61af66fc99e Initial load duke parents: diff changeset	803 void clear() { _entry = NULL; }
a61af66fc99e Initial load duke parents: diff changeset	804
a61af66fc99e Initial load duke parents: diff changeset	805 }; // End SymbolHashMapBucket class
a61af66fc99e Initial load duke parents: diff changeset	806
a61af66fc99e Initial load duke parents: diff changeset	807
a61af66fc99e Initial load duke parents: diff changeset	808 class SymbolHashMap: public CHeapObj {
a61af66fc99e Initial load duke parents: diff changeset	809
a61af66fc99e Initial load duke parents: diff changeset	810 private:
a61af66fc99e Initial load duke parents: diff changeset	811 // Default number of entries in the table
a61af66fc99e Initial load duke parents: diff changeset	812 enum SymbolHashMap_Constants {
a61af66fc99e Initial load duke parents: diff changeset	813 _Def_HashMap_Size = 256
a61af66fc99e Initial load duke parents: diff changeset	814 };
a61af66fc99e Initial load duke parents: diff changeset	815
a61af66fc99e Initial load duke parents: diff changeset	816 int _table_size;
a61af66fc99e Initial load duke parents: diff changeset	817 SymbolHashMapBucket* _buckets;
a61af66fc99e Initial load duke parents: diff changeset	818
a61af66fc99e Initial load duke parents: diff changeset	819 void initialize_table(int table_size) {
a61af66fc99e Initial load duke parents: diff changeset	820 _table_size = table_size;
a61af66fc99e Initial load duke parents: diff changeset	821 _buckets = NEW_C_HEAP_ARRAY(SymbolHashMapBucket, table_size);
a61af66fc99e Initial load duke parents: diff changeset	822 for (int index = 0; index < table_size; index++) {
a61af66fc99e Initial load duke parents: diff changeset	823 _buckets[index].clear();
a61af66fc99e Initial load duke parents: diff changeset	824 }
a61af66fc99e Initial load duke parents: diff changeset	825 }
a61af66fc99e Initial load duke parents: diff changeset	826
a61af66fc99e Initial load duke parents: diff changeset	827 public:
a61af66fc99e Initial load duke parents: diff changeset	828
a61af66fc99e Initial load duke parents: diff changeset	829 int table_size() const { return _table_size; }
a61af66fc99e Initial load duke parents: diff changeset	830
a61af66fc99e Initial load duke parents: diff changeset	831 SymbolHashMap() { initialize_table(_Def_HashMap_Size); }
a61af66fc99e Initial load duke parents: diff changeset	832 SymbolHashMap(int table_size) { initialize_table(table_size); }
a61af66fc99e Initial load duke parents: diff changeset	833
a61af66fc99e Initial load duke parents: diff changeset	834 // hash P(31) from Kernighan & Ritchie
a61af66fc99e Initial load duke parents: diff changeset	835 static unsigned int compute_hash(const char* str, int len) {
a61af66fc99e Initial load duke parents: diff changeset	836 unsigned int hash = 0;
a61af66fc99e Initial load duke parents: diff changeset	837 while (len-- > 0) {
a61af66fc99e Initial load duke parents: diff changeset	838 hash = 31hash + (unsigned) str;
a61af66fc99e Initial load duke parents: diff changeset	839 str++;
a61af66fc99e Initial load duke parents: diff changeset	840 }
a61af66fc99e Initial load duke parents: diff changeset	841 return hash;
a61af66fc99e Initial load duke parents: diff changeset	842 }
a61af66fc99e Initial load duke parents: diff changeset	843
a61af66fc99e Initial load duke parents: diff changeset	844 SymbolHashMapEntry* bucket(int i) {
a61af66fc99e Initial load duke parents: diff changeset	845 return _buckets[i].entry();
a61af66fc99e Initial load duke parents: diff changeset	846 }
a61af66fc99e Initial load duke parents: diff changeset	847
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	848 void add_entry(Symbol* sym, u2 value);
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	849 SymbolHashMapEntry* find_entry(Symbol* sym);
0 a61af66fc99e Initial load duke parents: diff changeset	850
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	851 u2 symbol_to_value(Symbol* sym) {
0 a61af66fc99e Initial load duke parents: diff changeset	852 SymbolHashMapEntry *entry = find_entry(sym);
a61af66fc99e Initial load duke parents: diff changeset	853 return (entry == NULL) ? 0 : entry->value();
a61af66fc99e Initial load duke parents: diff changeset	854 }
a61af66fc99e Initial load duke parents: diff changeset	855
a61af66fc99e Initial load duke parents: diff changeset	856 ~SymbolHashMap() {
a61af66fc99e Initial load duke parents: diff changeset	857 SymbolHashMapEntry* next;
a61af66fc99e Initial load duke parents: diff changeset	858 for (int i = 0; i < _table_size; i++) {
a61af66fc99e Initial load duke parents: diff changeset	859 for (SymbolHashMapEntry* cur = bucket(i); cur != NULL; cur = next) {
a61af66fc99e Initial load duke parents: diff changeset	860 next = cur->next();
a61af66fc99e Initial load duke parents: diff changeset	861 delete(cur);
a61af66fc99e Initial load duke parents: diff changeset	862 }
a61af66fc99e Initial load duke parents: diff changeset	863 }
a61af66fc99e Initial load duke parents: diff changeset	864 delete _buckets;
a61af66fc99e Initial load duke parents: diff changeset	865 }
a61af66fc99e Initial load duke parents: diff changeset	866 }; // End SymbolHashMap class
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1913 diff changeset	867
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1913 diff changeset	868 #endif // SHARE_VM_OOPS_CONSTANTPOOLOOP_HPP

Mercurial > hg > truffle

annotate src/share/vm/oops/constantPoolOop.hpp @ 4155:394404b2d9bd