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

annotate src/share/vm/oops/constantPoolOop.hpp @ 3762:5c0a3c1858b1

7048782: CMS: assert(last_chunk_index_to_check<= last_chunk_index) failed: parCardTableModRefBS.cpp:359 Summary: The LNC array is sized before the start of a scavenge, while the heap may expand during a scavenge. With CMS, the last block of an arbitrary suffice of the LNC array may expand due to coalition with the expansion delta. We now take care not to attempt access past the end of the LNC array. LNC array code will be cleaned up and suitably encapsulated as part of the forthcoming performance RFE 7043675. Reviewed-by: brutisso

author	ysr
date	Thu, 02 Jun 2011 10:23:36 -0700
parents	ed69575596ac
children	81d815b05abb

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,
431 a45484ea312d 6653858: dynamic languages need to be able to load anonymous classes jrose parents: 196 diff changeset	106 FB_has_pseudo_string = 2
a45484ea312d 6653858: dynamic languages need to be able to load anonymous classes jrose parents: 196 diff changeset	107 };
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 int flags() const { return _flags; }
a45484ea312d 6653858: dynamic languages need to be able to load anonymous classes jrose parents: 196 diff changeset	110 void set_flags(int f) { _flags = f; }
a45484ea312d 6653858: dynamic languages need to be able to load anonymous classes jrose parents: 196 diff changeset	111 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	112 void set_flag_at(FlagBit fb);
a45484ea312d 6653858: dynamic languages need to be able to load anonymous classes jrose parents: 196 diff changeset	113 // 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	114
0 a61af66fc99e Initial load duke parents: diff changeset	115 private:
a61af66fc99e Initial load duke parents: diff changeset	116 intptr_t* base() const { return (intptr_t) (((char) this) + sizeof(constantPoolOopDesc)); }
a61af66fc99e Initial load duke parents: diff changeset	117 oop* tags_addr() { return (oop*)&_tags; }
a61af66fc99e Initial load duke parents: diff changeset	118 oop* cache_addr() { return (oop*)&_cache; }
1913 3b2dea75431e 6984311: JSR 292 needs optional bootstrap method parameters jrose parents: 1910 diff changeset	119 oop* operands_addr() { return (oop*)&_operands; }
0 a61af66fc99e Initial load duke parents: diff changeset	120
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	121 CPSlot slot_at(int which) {
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	122 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	123 // 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	124 // 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	125 // 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	126 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	127 if (adr == 0 && which != 0) {
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	128 constantTag t = tag_at(which);
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	129 if (t.is_unresolved_klass() \|\| t.is_klass() \|\|
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	130 t.is_unresolved_string() \|\| t.is_string()) {
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	131 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	132 }
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 return CPSlot(adr);
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	135 }
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 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	138 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	139 (intptr_t)&base()[which] = s.value();
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	140 }
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	141 oop* obj_at_addr_raw(int which) const {
0 a61af66fc99e Initial load duke parents: diff changeset	142 assert(is_within_bounds(which), "index out of bounds");
a61af66fc99e Initial load duke parents: diff changeset	143 return (oop*) &base()[which];
a61af66fc99e Initial load duke parents: diff changeset	144 }
a61af66fc99e Initial load duke parents: diff changeset	145
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	146 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	147 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	148 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	149 }
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 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	152 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	153 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	154 }
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	155
0 a61af66fc99e Initial load duke parents: diff changeset	156 jint* int_at_addr(int which) const {
a61af66fc99e Initial load duke parents: diff changeset	157 assert(is_within_bounds(which), "index out of bounds");
a61af66fc99e Initial load duke parents: diff changeset	158 return (jint*) &base()[which];
a61af66fc99e Initial load duke parents: diff changeset	159 }
a61af66fc99e Initial load duke parents: diff changeset	160
a61af66fc99e Initial load duke parents: diff changeset	161 jlong* long_at_addr(int which) const {
a61af66fc99e Initial load duke parents: diff changeset	162 assert(is_within_bounds(which), "index out of bounds");
a61af66fc99e Initial load duke parents: diff changeset	163 return (jlong*) &base()[which];
a61af66fc99e Initial load duke parents: diff changeset	164 }
a61af66fc99e Initial load duke parents: diff changeset	165
a61af66fc99e Initial load duke parents: diff changeset	166 jfloat* float_at_addr(int which) const {
a61af66fc99e Initial load duke parents: diff changeset	167 assert(is_within_bounds(which), "index out of bounds");
a61af66fc99e Initial load duke parents: diff changeset	168 return (jfloat*) &base()[which];
a61af66fc99e Initial load duke parents: diff changeset	169 }
a61af66fc99e Initial load duke parents: diff changeset	170
a61af66fc99e Initial load duke parents: diff changeset	171 jdouble* double_at_addr(int which) const {
a61af66fc99e Initial load duke parents: diff changeset	172 assert(is_within_bounds(which), "index out of bounds");
a61af66fc99e Initial load duke parents: diff changeset	173 return (jdouble*) &base()[which];
a61af66fc99e Initial load duke parents: diff changeset	174 }
a61af66fc99e Initial load duke parents: diff changeset	175
a61af66fc99e Initial load duke parents: diff changeset	176 public:
a61af66fc99e Initial load duke parents: diff changeset	177 typeArrayOop tags() const { return _tags; }
1913 3b2dea75431e 6984311: JSR 292 needs optional bootstrap method parameters jrose parents: 1910 diff changeset	178 typeArrayOop operands() const { return _operands; }
0 a61af66fc99e Initial load duke parents: diff changeset	179
431 a45484ea312d 6653858: dynamic languages need to be able to load anonymous classes jrose parents: 196 diff changeset	180 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	181 bool has_invokedynamic() const { return flag_at(FB_has_invokedynamic); }
431 a45484ea312d 6653858: dynamic languages need to be able to load anonymous classes jrose parents: 196 diff changeset	182 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	183 void set_invokedynamic() { set_flag_at(FB_has_invokedynamic); }
431 a45484ea312d 6653858: dynamic languages need to be able to load anonymous classes jrose parents: 196 diff changeset	184
0 a61af66fc99e Initial load duke parents: diff changeset	185 // Klass holding pool
a61af66fc99e Initial load duke parents: diff changeset	186 klassOop pool_holder() const { return _pool_holder; }
a61af66fc99e Initial load duke parents: diff changeset	187 void set_pool_holder(klassOop k) { oop_store_without_check((oop*)&_pool_holder, (oop) k); }
a61af66fc99e Initial load duke parents: diff changeset	188 oop* pool_holder_addr() { return (oop*)&_pool_holder; }
a61af66fc99e Initial load duke parents: diff changeset	189
a61af66fc99e Initial load duke parents: diff changeset	190 // Interpreter runtime support
a61af66fc99e Initial load duke parents: diff changeset	191 constantPoolCacheOop cache() const { return _cache; }
a61af66fc99e Initial load duke parents: diff changeset	192 void set_cache(constantPoolCacheOop cache){ oop_store((oop*)&_cache, cache); }
a61af66fc99e Initial load duke parents: diff changeset	193
a61af66fc99e Initial load duke parents: diff changeset	194 // Assembly code support
a61af66fc99e Initial load duke parents: diff changeset	195 static int tags_offset_in_bytes() { return offset_of(constantPoolOopDesc, _tags); }
a61af66fc99e Initial load duke parents: diff changeset	196 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	197 static int operands_offset_in_bytes() { return offset_of(constantPoolOopDesc, _operands); }
0 a61af66fc99e Initial load duke parents: diff changeset	198 static int pool_holder_offset_in_bytes() { return offset_of(constantPoolOopDesc, _pool_holder); }
a61af66fc99e Initial load duke parents: diff changeset	199
a61af66fc99e Initial load duke parents: diff changeset	200 // Storing constants
a61af66fc99e Initial load duke parents: diff changeset	201
a61af66fc99e Initial load duke parents: diff changeset	202 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	203 // 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	204 // 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	205 // assert the symbol is not an oop.
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	206 *obj_at_addr_raw(which) = NULL;
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	207 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	208 obj_at_put_without_check(which, k);
0 a61af66fc99e Initial load duke parents: diff changeset	209 // 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	210 // and the klassOop is a klass rather than a Symbol*, so we need
0 a61af66fc99e Initial load duke parents: diff changeset	211 // hardware store ordering here.
a61af66fc99e Initial load duke parents: diff changeset	212 release_tag_at_put(which, JVM_CONSTANT_Class);
a61af66fc99e Initial load duke parents: diff changeset	213 if (UseConcMarkSweepGC) {
a61af66fc99e Initial load duke parents: diff changeset	214 // In case the earlier card-mark was consumed by a concurrent
a61af66fc99e Initial load duke parents: diff changeset	215 // 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	216 obj_at_put_without_check(which, k);
0 a61af66fc99e Initial load duke parents: diff changeset	217 }
a61af66fc99e Initial load duke parents: diff changeset	218 }
a61af66fc99e Initial load duke parents: diff changeset	219
a61af66fc99e Initial load duke parents: diff changeset	220 // For temporary use while constructing constant pool
a61af66fc99e Initial load duke parents: diff changeset	221 void klass_index_at_put(int which, int name_index) {
a61af66fc99e Initial load duke parents: diff changeset	222 tag_at_put(which, JVM_CONSTANT_ClassIndex);
a61af66fc99e Initial load duke parents: diff changeset	223 *int_at_addr(which) = name_index;
a61af66fc99e Initial load duke parents: diff changeset	224 }
a61af66fc99e Initial load duke parents: diff changeset	225
a61af66fc99e Initial load duke parents: diff changeset	226 // Temporary until actual use
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	227 void unresolved_klass_at_put(int which, Symbol* s) {
0 a61af66fc99e Initial load duke parents: diff changeset	228 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	229 slot_at_put(which, s);
0 a61af66fc99e Initial load duke parents: diff changeset	230 }
a61af66fc99e Initial load duke parents: diff changeset	231
1602 136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	232 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	233 tag_at_put(which, JVM_CONSTANT_MethodHandle);
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	234 *int_at_addr(which) = ((jint) ref_index<<16) \| ref_kind;
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	235 }
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	236
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	237 void method_type_index_at_put(int which, int ref_index) {
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	238 tag_at_put(which, JVM_CONSTANT_MethodType);
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	239 *int_at_addr(which) = ref_index;
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	240 }
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	241
2011 dad31fc330cd 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute jrose parents: 1972 diff changeset	242 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	243 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	244 *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	245 }
2011 dad31fc330cd 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute jrose parents: 1972 diff changeset	246
0 a61af66fc99e Initial load duke parents: diff changeset	247 // Temporary until actual use
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	248 void unresolved_string_at_put(int which, Symbol* s) {
0 a61af66fc99e Initial load duke parents: diff changeset	249 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	250 slot_at_put(which, s);
0 a61af66fc99e Initial load duke parents: diff changeset	251 }
a61af66fc99e Initial load duke parents: diff changeset	252
a61af66fc99e Initial load duke parents: diff changeset	253 void int_at_put(int which, jint i) {
a61af66fc99e Initial load duke parents: diff changeset	254 tag_at_put(which, JVM_CONSTANT_Integer);
a61af66fc99e Initial load duke parents: diff changeset	255 *int_at_addr(which) = i;
a61af66fc99e Initial load duke parents: diff changeset	256 }
a61af66fc99e Initial load duke parents: diff changeset	257
a61af66fc99e Initial load duke parents: diff changeset	258 void long_at_put(int which, jlong l) {
a61af66fc99e Initial load duke parents: diff changeset	259 tag_at_put(which, JVM_CONSTANT_Long);
a61af66fc99e Initial load duke parents: diff changeset	260 // *long_at_addr(which) = l;
a61af66fc99e Initial load duke parents: diff changeset	261 Bytes::put_native_u8((address)long_at_addr(which), ((u8) &l));
a61af66fc99e Initial load duke parents: diff changeset	262 }
a61af66fc99e Initial load duke parents: diff changeset	263
a61af66fc99e Initial load duke parents: diff changeset	264 void float_at_put(int which, jfloat f) {
a61af66fc99e Initial load duke parents: diff changeset	265 tag_at_put(which, JVM_CONSTANT_Float);
a61af66fc99e Initial load duke parents: diff changeset	266 *float_at_addr(which) = f;
a61af66fc99e Initial load duke parents: diff changeset	267 }
a61af66fc99e Initial load duke parents: diff changeset	268
a61af66fc99e Initial load duke parents: diff changeset	269 void double_at_put(int which, jdouble d) {
a61af66fc99e Initial load duke parents: diff changeset	270 tag_at_put(which, JVM_CONSTANT_Double);
a61af66fc99e Initial load duke parents: diff changeset	271 // *double_at_addr(which) = d;
a61af66fc99e Initial load duke parents: diff changeset	272 // u8 temp = (u8) &d;
a61af66fc99e Initial load duke parents: diff changeset	273 Bytes::put_native_u8((address) double_at_addr(which), ((u8) &d));
a61af66fc99e Initial load duke parents: diff changeset	274 }
a61af66fc99e Initial load duke parents: diff changeset	275
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	276 Symbol** symbol_at_addr(int which) const {
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	277 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	278 return (Symbol**) &base()[which];
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	279 }
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	280
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	281 void symbol_at_put(int which, Symbol* s) {
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	282 assert(s->refcount() != 0, "should have nonzero refcount");
0 a61af66fc99e Initial load duke parents: diff changeset	283 tag_at_put(which, JVM_CONSTANT_Utf8);
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	284 slot_at_put(which, s);
0 a61af66fc99e Initial load duke parents: diff changeset	285 }
a61af66fc99e Initial load duke parents: diff changeset	286
a61af66fc99e Initial load duke parents: diff changeset	287 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	288 // 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	289 // 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	290 // assert the symbol is not an oop.
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	291 *obj_at_addr_raw(which) = NULL;
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	292 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	293 obj_at_put(which, str);
0 a61af66fc99e Initial load duke parents: diff changeset	294 release_tag_at_put(which, JVM_CONSTANT_String);
a61af66fc99e Initial load duke parents: diff changeset	295 if (UseConcMarkSweepGC) {
a61af66fc99e Initial load duke parents: diff changeset	296 // In case the earlier card-mark was consumed by a concurrent
a61af66fc99e Initial load duke parents: diff changeset	297 // 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	298 obj_at_put_without_check(which, str);
0 a61af66fc99e Initial load duke parents: diff changeset	299 }
a61af66fc99e Initial load duke parents: diff changeset	300 }
a61af66fc99e Initial load duke parents: diff changeset	301
1138 dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1059 diff changeset	302 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	303 obj_at_put(which, str);
1138 dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1059 diff changeset	304 release_tag_at_put(which, JVM_CONSTANT_Object);
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1059 diff changeset	305 if (UseConcMarkSweepGC) {
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1059 diff changeset	306 // 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	307 // 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	308 obj_at_put_without_check(which, str);
1138 dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1059 diff changeset	309 }
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1059 diff changeset	310 }
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1059 diff changeset	311
0 a61af66fc99e Initial load duke parents: diff changeset	312 // For temporary use while constructing constant pool
a61af66fc99e Initial load duke parents: diff changeset	313 void string_index_at_put(int which, int string_index) {
a61af66fc99e Initial load duke parents: diff changeset	314 tag_at_put(which, JVM_CONSTANT_StringIndex);
a61af66fc99e Initial load duke parents: diff changeset	315 *int_at_addr(which) = string_index;
a61af66fc99e Initial load duke parents: diff changeset	316 }
a61af66fc99e Initial load duke parents: diff changeset	317
a61af66fc99e Initial load duke parents: diff changeset	318 void field_at_put(int which, int class_index, int name_and_type_index) {
a61af66fc99e Initial load duke parents: diff changeset	319 tag_at_put(which, JVM_CONSTANT_Fieldref);
a61af66fc99e Initial load duke parents: diff changeset	320 *int_at_addr(which) = ((jint) name_and_type_index<<16) \| class_index;
a61af66fc99e Initial load duke parents: diff changeset	321 }
a61af66fc99e Initial load duke parents: diff changeset	322
a61af66fc99e Initial load duke parents: diff changeset	323 void method_at_put(int which, int class_index, int name_and_type_index) {
a61af66fc99e Initial load duke parents: diff changeset	324 tag_at_put(which, JVM_CONSTANT_Methodref);
a61af66fc99e Initial load duke parents: diff changeset	325 *int_at_addr(which) = ((jint) name_and_type_index<<16) \| class_index;
a61af66fc99e Initial load duke parents: diff changeset	326 }
a61af66fc99e Initial load duke parents: diff changeset	327
a61af66fc99e Initial load duke parents: diff changeset	328 void interface_method_at_put(int which, int class_index, int name_and_type_index) {
a61af66fc99e Initial load duke parents: diff changeset	329 tag_at_put(which, JVM_CONSTANT_InterfaceMethodref);
a61af66fc99e Initial load duke parents: diff changeset	330 *int_at_addr(which) = ((jint) name_and_type_index<<16) \| class_index; // Not so nice
a61af66fc99e Initial load duke parents: diff changeset	331 }
a61af66fc99e Initial load duke parents: diff changeset	332
a61af66fc99e Initial load duke parents: diff changeset	333 void name_and_type_at_put(int which, int name_index, int signature_index) {
a61af66fc99e Initial load duke parents: diff changeset	334 tag_at_put(which, JVM_CONSTANT_NameAndType);
a61af66fc99e Initial load duke parents: diff changeset	335 *int_at_addr(which) = ((jint) signature_index<<16) \| name_index; // Not so nice
a61af66fc99e Initial load duke parents: diff changeset	336 }
a61af66fc99e Initial load duke parents: diff changeset	337
a61af66fc99e Initial load duke parents: diff changeset	338 // Tag query
a61af66fc99e Initial load duke parents: diff changeset	339
a61af66fc99e Initial load duke parents: diff changeset	340 constantTag tag_at(int which) const { return (constantTag)tags()->byte_at_acquire(which); }
a61af66fc99e Initial load duke parents: diff changeset	341
a61af66fc99e Initial load duke parents: diff changeset	342 // Whether the entry is a pointer that must be GC'd.
a61af66fc99e Initial load duke parents: diff changeset	343 bool is_pointer_entry(int which) {
a61af66fc99e Initial load duke parents: diff changeset	344 constantTag tag = tag_at(which);
a61af66fc99e Initial load duke parents: diff changeset	345 return tag.is_klass() \|\|
1138 dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1059 diff changeset	346 tag.is_string() \|\|
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1059 diff changeset	347 tag.is_object();
0 a61af66fc99e Initial load duke parents: diff changeset	348 }
a61af66fc99e Initial load duke parents: diff changeset	349
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	350 // 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	351 bool is_object_entry(int which) {
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	352 constantTag tag = tag_at(which);
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	353 return is_pointer_entry(which) \|\|
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	354 tag.is_unresolved_klass() \|\|
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	355 tag.is_unresolved_string() \|\|
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	356 tag.is_symbol();
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	357 }
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	358
0 a61af66fc99e Initial load duke parents: diff changeset	359 // Fetching constants
a61af66fc99e Initial load duke parents: diff changeset	360
a61af66fc99e Initial load duke parents: diff changeset	361 klassOop klass_at(int which, TRAPS) {
a61af66fc99e Initial load duke parents: diff changeset	362 constantPoolHandle h_this(THREAD, this);
a61af66fc99e Initial load duke parents: diff changeset	363 return klass_at_impl(h_this, which, CHECK_NULL);
a61af66fc99e Initial load duke parents: diff changeset	364 }
a61af66fc99e Initial load duke parents: diff changeset	365
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	366 Symbol* klass_name_at(int which); // Returns the name, w/o resolving.
0 a61af66fc99e Initial load duke parents: diff changeset	367
a61af66fc99e Initial load duke parents: diff changeset	368 klassOop resolved_klass_at(int which) { // Used by Compiler
a61af66fc99e Initial load duke parents: diff changeset	369 guarantee(tag_at(which).is_klass(), "Corrupted constant pool");
a61af66fc99e Initial load duke parents: diff changeset	370 // Must do an acquire here in case another thread resolved the klass
a61af66fc99e Initial load duke parents: diff changeset	371 // 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	372 return klassOop(CPSlot(OrderAccess::load_ptr_acquire(obj_at_addr_raw(which))).get_oop());
0 a61af66fc99e Initial load duke parents: diff changeset	373 }
a61af66fc99e Initial load duke parents: diff changeset	374
a61af66fc99e Initial load duke parents: diff changeset	375 // 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	376 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	377 Symbol* s = CPSlot(OrderAccess::load_ptr_acquire(obj_at_addr_raw(which))).get_symbol();
0 a61af66fc99e Initial load duke parents: diff changeset	378 // check that the klass is still unresolved.
a61af66fc99e Initial load duke parents: diff changeset	379 assert(tag_at(which).is_unresolved_klass(), "Corrupted constant pool");
a61af66fc99e Initial load duke parents: diff changeset	380 return s;
a61af66fc99e Initial load duke parents: diff changeset	381 }
a61af66fc99e Initial load duke parents: diff changeset	382
a61af66fc99e Initial load duke parents: diff changeset	383 // RedefineClasses() API support:
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	384 Symbol* klass_at_noresolve(int which) { return klass_name_at(which); }
0 a61af66fc99e Initial load duke parents: diff changeset	385
a61af66fc99e Initial load duke parents: diff changeset	386 jint int_at(int which) {
a61af66fc99e Initial load duke parents: diff changeset	387 assert(tag_at(which).is_int(), "Corrupted constant pool");
a61af66fc99e Initial load duke parents: diff changeset	388 return *int_at_addr(which);
a61af66fc99e Initial load duke parents: diff changeset	389 }
a61af66fc99e Initial load duke parents: diff changeset	390
a61af66fc99e Initial load duke parents: diff changeset	391 jlong long_at(int which) {
a61af66fc99e Initial load duke parents: diff changeset	392 assert(tag_at(which).is_long(), "Corrupted constant pool");
a61af66fc99e Initial load duke parents: diff changeset	393 // return *long_at_addr(which);
a61af66fc99e Initial load duke parents: diff changeset	394 u8 tmp = Bytes::get_native_u8((address)&base()[which]);
a61af66fc99e Initial load duke parents: diff changeset	395 return ((jlong)&tmp);
a61af66fc99e Initial load duke parents: diff changeset	396 }
a61af66fc99e Initial load duke parents: diff changeset	397
a61af66fc99e Initial load duke parents: diff changeset	398 jfloat float_at(int which) {
a61af66fc99e Initial load duke parents: diff changeset	399 assert(tag_at(which).is_float(), "Corrupted constant pool");
a61af66fc99e Initial load duke parents: diff changeset	400 return *float_at_addr(which);
a61af66fc99e Initial load duke parents: diff changeset	401 }
a61af66fc99e Initial load duke parents: diff changeset	402
a61af66fc99e Initial load duke parents: diff changeset	403 jdouble double_at(int which) {
a61af66fc99e Initial load duke parents: diff changeset	404 assert(tag_at(which).is_double(), "Corrupted constant pool");
a61af66fc99e Initial load duke parents: diff changeset	405 u8 tmp = Bytes::get_native_u8((address)&base()[which]);
a61af66fc99e Initial load duke parents: diff changeset	406 return ((jdouble)&tmp);
a61af66fc99e Initial load duke parents: diff changeset	407 }
a61af66fc99e Initial load duke parents: diff changeset	408
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	409 Symbol* symbol_at(int which) {
0 a61af66fc99e Initial load duke parents: diff changeset	410 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	411 return slot_at(which).get_symbol();
0 a61af66fc99e Initial load duke parents: diff changeset	412 }
a61af66fc99e Initial load duke parents: diff changeset	413
a61af66fc99e Initial load duke parents: diff changeset	414 oop string_at(int which, TRAPS) {
a61af66fc99e Initial load duke parents: diff changeset	415 constantPoolHandle h_this(THREAD, this);
a61af66fc99e Initial load duke parents: diff changeset	416 return string_at_impl(h_this, which, CHECK_NULL);
a61af66fc99e Initial load duke parents: diff changeset	417 }
a61af66fc99e Initial load duke parents: diff changeset	418
1138 dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1059 diff changeset	419 oop object_at(int which) {
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1059 diff changeset	420 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	421 return slot_at(which).get_oop();
1138 dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1059 diff changeset	422 }
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1059 diff changeset	423
431 a45484ea312d 6653858: dynamic languages need to be able to load anonymous classes jrose parents: 196 diff changeset	424 // 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	425 // a String entry.
2416 38fea01eb669 6817525: turn on method handle functionality by default for JSR 292 twisti parents: 2192 diff changeset	426 // 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	427 // 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	428 // 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	429 // 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	430
a45484ea312d 6653858: dynamic languages need to be able to load anonymous classes jrose parents: 196 diff changeset	431 bool is_pseudo_string_at(int which);
a45484ea312d 6653858: dynamic languages need to be able to load anonymous classes jrose parents: 196 diff changeset	432
a45484ea312d 6653858: dynamic languages need to be able to load anonymous classes jrose parents: 196 diff changeset	433 oop pseudo_string_at(int which) {
a45484ea312d 6653858: dynamic languages need to be able to load anonymous classes jrose parents: 196 diff changeset	434 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	435 return slot_at(which).get_oop();
431 a45484ea312d 6653858: dynamic languages need to be able to load anonymous classes jrose parents: 196 diff changeset	436 }
a45484ea312d 6653858: dynamic languages need to be able to load anonymous classes jrose parents: 196 diff changeset	437
a45484ea312d 6653858: dynamic languages need to be able to load anonymous classes jrose parents: 196 diff changeset	438 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	439 assert(EnableInvokeDynamic, "");
431 a45484ea312d 6653858: dynamic languages need to be able to load anonymous classes jrose parents: 196 diff changeset	440 set_pseudo_string(); // mark header
a45484ea312d 6653858: dynamic languages need to be able to load anonymous classes jrose parents: 196 diff changeset	441 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	442 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	443 }
a45484ea312d 6653858: dynamic languages need to be able to load anonymous classes jrose parents: 196 diff changeset	444
0 a61af66fc99e Initial load duke parents: diff changeset	445 // only called when we are sure a string entry is already resolved (via an
a61af66fc99e Initial load duke parents: diff changeset	446 // earlier string_at call.
a61af66fc99e Initial load duke parents: diff changeset	447 oop resolved_string_at(int which) {
a61af66fc99e Initial load duke parents: diff changeset	448 assert(tag_at(which).is_string(), "Corrupted constant pool");
a61af66fc99e Initial load duke parents: diff changeset	449 // Must do an acquire here in case another thread resolved the klass
a61af66fc99e Initial load duke parents: diff changeset	450 // 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	451 return CPSlot(OrderAccess::load_ptr_acquire(obj_at_addr_raw(which))).get_oop();
0 a61af66fc99e Initial load duke parents: diff changeset	452 }
a61af66fc99e Initial load duke parents: diff changeset	453
a61af66fc99e Initial load duke parents: diff changeset	454 // 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	455 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	456 Symbol* s = CPSlot(OrderAccess::load_ptr_acquire(obj_at_addr_raw(which))).get_symbol();
0 a61af66fc99e Initial load duke parents: diff changeset	457 // check that the string is still unresolved.
a61af66fc99e Initial load duke parents: diff changeset	458 assert(tag_at(which).is_unresolved_string(), "Corrupted constant pool");
a61af66fc99e Initial load duke parents: diff changeset	459 return s;
a61af66fc99e Initial load duke parents: diff changeset	460 }
a61af66fc99e Initial load duke parents: diff changeset	461
a61af66fc99e Initial load duke parents: diff changeset	462 // Returns an UTF8 for a CONSTANT_String entry at a given index.
a61af66fc99e Initial load duke parents: diff changeset	463 // 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	464 // java_lang_Strings at resolved entries into Symbol*s
0 a61af66fc99e Initial load duke parents: diff changeset	465 // or vice versa.
431 a45484ea312d 6653858: dynamic languages need to be able to load anonymous classes jrose parents: 196 diff changeset	466 // Caller is responsible for checking for pseudo-strings.
0 a61af66fc99e Initial load duke parents: diff changeset	467 char* string_at_noresolve(int which);
a61af66fc99e Initial load duke parents: diff changeset	468
a61af66fc99e Initial load duke parents: diff changeset	469 jint name_and_type_at(int which) {
a61af66fc99e Initial load duke parents: diff changeset	470 assert(tag_at(which).is_name_and_type(), "Corrupted constant pool");
a61af66fc99e Initial load duke parents: diff changeset	471 return *int_at_addr(which);
a61af66fc99e Initial load duke parents: diff changeset	472 }
a61af66fc99e Initial load duke parents: diff changeset	473
1602 136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	474 int method_handle_ref_kind_at(int which) {
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	475 assert(tag_at(which).is_method_handle(), "Corrupted constant pool");
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	476 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	477 }
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	478 int method_handle_index_at(int which) {
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	479 assert(tag_at(which).is_method_handle(), "Corrupted constant pool");
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	480 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	481 }
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	482 int method_type_index_at(int which) {
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	483 assert(tag_at(which).is_method_type(), "Corrupted constant pool");
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	484 return *int_at_addr(which);
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	485 }
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	486 // Derived queries:
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	487 Symbol* method_handle_name_ref_at(int which) {
1602 136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	488 int member = method_handle_index_at(which);
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	489 return impl_name_ref_at(member, true);
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	490 }
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	491 Symbol* method_handle_signature_ref_at(int which) {
1602 136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	492 int member = method_handle_index_at(which);
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	493 return impl_signature_ref_at(member, true);
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	494 }
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	495 int method_handle_klass_index_at(int which) {
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	496 int member = method_handle_index_at(which);
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	497 return impl_klass_ref_index_at(member, true);
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	498 }
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	499 Symbol* method_type_signature_at(int which) {
1602 136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	500 int sym = method_type_index_at(which);
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	501 return symbol_at(sym);
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	502 }
1913 3b2dea75431e 6984311: JSR 292 needs optional bootstrap method parameters jrose parents: 1910 diff changeset	503
2011 dad31fc330cd 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute jrose parents: 1972 diff changeset	504 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	505 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	506 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	507 }
2011 dad31fc330cd 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute jrose parents: 1972 diff changeset	508 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	509 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	510 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	511 }
dad31fc330cd 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute jrose parents: 1972 diff changeset	512 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	513 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	514 return operand_offset_at(operands(), bootstrap_specifier_index);
1913 3b2dea75431e 6984311: JSR 292 needs optional bootstrap method parameters jrose parents: 1910 diff changeset	515 }
2011 dad31fc330cd 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute jrose parents: 1972 diff changeset	516 // 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	517 // 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	518 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	519 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	520 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	521 // 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	522 // 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	523 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	524 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	525 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	526 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	527 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	528 // 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	529 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	530 return offset;
1913 3b2dea75431e 6984311: JSR 292 needs optional bootstrap method parameters jrose parents: 1910 diff changeset	531 }
2011 dad31fc330cd 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute jrose parents: 1972 diff changeset	532 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	533 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	534 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	535 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	536 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	537 }
dad31fc330cd 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute jrose parents: 1972 diff changeset	538 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	539 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	540 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	541 return (second_part / 2);
1913 3b2dea75431e 6984311: JSR 292 needs optional bootstrap method parameters jrose parents: 1910 diff changeset	542 }
3b2dea75431e 6984311: JSR 292 needs optional bootstrap method parameters jrose parents: 1910 diff changeset	543
2011 dad31fc330cd 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute jrose parents: 1972 diff changeset	544 #ifdef ASSERT
dad31fc330cd 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute jrose parents: 1972 diff changeset	545 // 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	546 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	547 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	548 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	549 return operands->length();
dad31fc330cd 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute jrose parents: 1972 diff changeset	550 else
dad31fc330cd 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute jrose parents: 1972 diff changeset	551 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	552 }
dad31fc330cd 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute jrose parents: 1972 diff changeset	553 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	554 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	555 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	556 }
dad31fc330cd 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute jrose parents: 1972 diff changeset	557 #endif //ASSERT
dad31fc330cd 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute jrose parents: 1972 diff changeset	558
dad31fc330cd 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute jrose parents: 1972 diff changeset	559 // 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	560 enum {
3b2dea75431e 6984311: JSR 292 needs optional bootstrap method parameters jrose parents: 1910 diff changeset	561 _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	562 _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	563 _indy_argv_offset = 2 // u2 argv[argc]
1913 3b2dea75431e 6984311: JSR 292 needs optional bootstrap method parameters jrose parents: 1910 diff changeset	564 };
1660 083fde3b838e 6964498: JSR 292 invokedynamic sites need local bootstrap methods jrose parents: 1602 diff changeset	565 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	566 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	567 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	568 return operands()->short_at(op_base + _indy_bsm_offset);
1913 3b2dea75431e 6984311: JSR 292 needs optional bootstrap method parameters jrose parents: 1910 diff changeset	569 }
3b2dea75431e 6984311: JSR 292 needs optional bootstrap method parameters jrose parents: 1910 diff changeset	570 int invoke_dynamic_argument_count_at(int which) {
3b2dea75431e 6984311: JSR 292 needs optional bootstrap method parameters jrose parents: 1910 diff changeset	571 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	572 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	573 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	574 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	575 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	576 assert(end_offset == next_offset, "matched ending");
1913 3b2dea75431e 6984311: JSR 292 needs optional bootstrap method parameters jrose parents: 1910 diff changeset	577 return argc;
3b2dea75431e 6984311: JSR 292 needs optional bootstrap method parameters jrose parents: 1910 diff changeset	578 }
3b2dea75431e 6984311: JSR 292 needs optional bootstrap method parameters jrose parents: 1910 diff changeset	579 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	580 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	581 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	582 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	583 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	584 }
1602 136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	585
726 be93aad57795 6655646: dynamic languages need dynamically linked call sites jrose parents: 579 diff changeset	586 // 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	587 // 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	588 // directly from the bytecode.
1059 389049f3f393 6858164: invokedynamic code needs some cleanup (post-6655638) jrose parents: 726 diff changeset	589 // 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	590 // actually rewritten constant pool cache indices.
1059 389049f3f393 6858164: invokedynamic code needs some cleanup (post-6655638) jrose parents: 726 diff changeset	591 // The routine remap_instruction_operand_from_cache manages the adjustment
389049f3f393 6858164: invokedynamic code needs some cleanup (post-6655638) jrose parents: 726 diff changeset	592 // of these values back to constant pool indices.
726 be93aad57795 6655646: dynamic languages need dynamically linked call sites jrose parents: 579 diff changeset	593
1059 389049f3f393 6858164: invokedynamic code needs some cleanup (post-6655638) jrose parents: 726 diff changeset	594 // There are also "uncached" versions which do not adjust the operand index; see below.
0 a61af66fc99e Initial load duke parents: diff changeset	595
1910 d1896d1dda3e 6981788: GC map generator sometimes picks up the wrong kind of instruction operand jrose parents: 1660 diff changeset	596 // 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	597 // 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	598 // 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	599 // 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	600
0 a61af66fc99e Initial load duke parents: diff changeset	601 // Lookup for entries consisting of (klass_index, name_and_type index)
a61af66fc99e Initial load duke parents: diff changeset	602 klassOop klass_ref_at(int which, TRAPS);
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	603 Symbol* klass_ref_at_noresolve(int which);
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	604 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	605 Symbol* signature_ref_at(int which) { return impl_signature_ref_at(which, false); }
0 a61af66fc99e Initial load duke parents: diff changeset	606
726 be93aad57795 6655646: dynamic languages need dynamically linked call sites jrose parents: 579 diff changeset	607 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	608 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	609
a61af66fc99e Initial load duke parents: diff changeset	610 // Lookup for entries consisting of (name_index, signature_index)
726 be93aad57795 6655646: dynamic languages need dynamically linked call sites jrose parents: 579 diff changeset	611 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	612 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	613
a61af66fc99e Initial load duke parents: diff changeset	614 BasicType basic_type_for_signature_at(int which);
a61af66fc99e Initial load duke parents: diff changeset	615
a61af66fc99e Initial load duke parents: diff changeset	616 // Resolve string constants (to prevent allocation during compilation)
a61af66fc99e Initial load duke parents: diff changeset	617 void resolve_string_constants(TRAPS) {
a61af66fc99e Initial load duke parents: diff changeset	618 constantPoolHandle h_this(THREAD, this);
a61af66fc99e Initial load duke parents: diff changeset	619 resolve_string_constants_impl(h_this, CHECK);
a61af66fc99e Initial load duke parents: diff changeset	620 }
a61af66fc99e Initial load duke parents: diff changeset	621
1913 3b2dea75431e 6984311: JSR 292 needs optional bootstrap method parameters jrose parents: 1910 diff changeset	622 private:
3b2dea75431e 6984311: JSR 292 needs optional bootstrap method parameters jrose parents: 1910 diff changeset	623 enum { _no_index_sentinel = -1, _possible_index_sentinel = -2 };
3b2dea75431e 6984311: JSR 292 needs optional bootstrap method parameters jrose parents: 1910 diff changeset	624 public:
3b2dea75431e 6984311: JSR 292 needs optional bootstrap method parameters jrose parents: 1910 diff changeset	625
1602 136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	626 // Resolve late bound constants.
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	627 oop resolve_constant_at(int index, TRAPS) {
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	628 constantPoolHandle h_this(THREAD, this);
1913 3b2dea75431e 6984311: JSR 292 needs optional bootstrap method parameters jrose parents: 1910 diff changeset	629 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	630 }
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	631
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	632 oop resolve_cached_constant_at(int cache_index, TRAPS) {
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	633 constantPoolHandle h_this(THREAD, this);
1913 3b2dea75431e 6984311: JSR 292 needs optional bootstrap method parameters jrose parents: 1910 diff changeset	634 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	635 }
3b2dea75431e 6984311: JSR 292 needs optional bootstrap method parameters jrose parents: 1910 diff changeset	636
3b2dea75431e 6984311: JSR 292 needs optional bootstrap method parameters jrose parents: 1910 diff changeset	637 oop resolve_possibly_cached_constant_at(int pool_index, TRAPS) {
3b2dea75431e 6984311: JSR 292 needs optional bootstrap method parameters jrose parents: 1910 diff changeset	638 constantPoolHandle h_this(THREAD, this);
3b2dea75431e 6984311: JSR 292 needs optional bootstrap method parameters jrose parents: 1910 diff changeset	639 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	640 }
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	641
0 a61af66fc99e Initial load duke parents: diff changeset	642 // Klass name matches name at offset
a61af66fc99e Initial load duke parents: diff changeset	643 bool klass_name_at_matches(instanceKlassHandle k, int which);
a61af66fc99e Initial load duke parents: diff changeset	644
a61af66fc99e Initial load duke parents: diff changeset	645 // Sizing
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	646 int length() const { return _length; }
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	647 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	648
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	649 // 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	650 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	651 return 0 <= index && index < length();
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	652 }
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	653
0 a61af66fc99e Initial load duke parents: diff changeset	654 static int header_size() { return sizeof(constantPoolOopDesc)/HeapWordSize; }
a61af66fc99e Initial load duke parents: diff changeset	655 static int object_size(int length) { return align_object_size(header_size() + length); }
a61af66fc99e Initial load duke parents: diff changeset	656 int object_size() { return object_size(length()); }
a61af66fc99e Initial load duke parents: diff changeset	657
518 0af8b0718fc9 6692899: CMS: many vm.parallel_class_loading tests fail with assert "missing Printezis mark" jmasa parents: 431 diff changeset	658 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	659 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	660
0 a61af66fc99e Initial load duke parents: diff changeset	661 friend class constantPoolKlass;
a61af66fc99e Initial load duke parents: diff changeset	662 friend class ClassFileParser;
a61af66fc99e Initial load duke parents: diff changeset	663 friend class SystemDictionary;
a61af66fc99e Initial load duke parents: diff changeset	664
a61af66fc99e Initial load duke parents: diff changeset	665 // Used by compiler to prevent classloading.
a61af66fc99e Initial load duke parents: diff changeset	666 static klassOop klass_at_if_loaded (constantPoolHandle this_oop, int which);
a61af66fc99e Initial load duke parents: diff changeset	667 static klassOop klass_ref_at_if_loaded (constantPoolHandle this_oop, int which);
a61af66fc99e Initial load duke parents: diff changeset	668 // Same as above - but does LinkResolving.
a61af66fc99e Initial load duke parents: diff changeset	669 static klassOop klass_ref_at_if_loaded_check(constantPoolHandle this_oop, int which, TRAPS);
a61af66fc99e Initial load duke parents: diff changeset	670
a61af66fc99e Initial load duke parents: diff changeset	671 // 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	672 // future by other Java code. These take constant pool indices rather than
0 a61af66fc99e Initial load duke parents: diff changeset	673 // 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	674 Symbol* uncached_klass_ref_at_noresolve(int which);
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	675 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	676 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	677 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	678 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	679
a61af66fc99e Initial load duke parents: diff changeset	680 // Sharing
a61af66fc99e Initial load duke parents: diff changeset	681 int pre_resolve_shared_klasses(TRAPS);
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	682 void shared_symbols_iterate(SymbolClosure* closure0);
0 a61af66fc99e Initial load duke parents: diff changeset	683 void shared_tags_iterate(OopClosure* closure0);
a61af66fc99e Initial load duke parents: diff changeset	684 void shared_strings_iterate(OopClosure* closure0);
a61af66fc99e Initial load duke parents: diff changeset	685
a61af66fc99e Initial load duke parents: diff changeset	686 // Debugging
a61af66fc99e Initial load duke parents: diff changeset	687 const char* printable_name_at(int which) PRODUCT_RETURN0;
a61af66fc99e Initial load duke parents: diff changeset	688
1565 ab102d5d923e 6939207: refactor constant pool index processing jrose parents: 1138 diff changeset	689 #ifdef ASSERT
ab102d5d923e 6939207: refactor constant pool index processing jrose parents: 1138 diff changeset	690 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	691 #else
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	692 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	693 #endif //ASSERT
ab102d5d923e 6939207: refactor constant pool index processing jrose parents: 1138 diff changeset	694
0 a61af66fc99e Initial load duke parents: diff changeset	695 private:
a61af66fc99e Initial load duke parents: diff changeset	696
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	697 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	698 Symbol* impl_signature_ref_at(int which, bool uncached);
726 be93aad57795 6655646: dynamic languages need dynamically linked call sites jrose parents: 579 diff changeset	699 int impl_klass_ref_index_at(int which, bool uncached);
be93aad57795 6655646: dynamic languages need dynamically linked call sites jrose parents: 579 diff changeset	700 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	701
1565 ab102d5d923e 6939207: refactor constant pool index processing jrose parents: 1138 diff changeset	702 int remap_instruction_operand_from_cache(int operand); // operand must be biased by CPCACHE_INDEX_TAG
0 a61af66fc99e Initial load duke parents: diff changeset	703
a61af66fc99e Initial load duke parents: diff changeset	704 // Used while constructing constant pool (only by ClassFileParser)
a61af66fc99e Initial load duke parents: diff changeset	705 jint klass_index_at(int which) {
a61af66fc99e Initial load duke parents: diff changeset	706 assert(tag_at(which).is_klass_index(), "Corrupted constant pool");
a61af66fc99e Initial load duke parents: diff changeset	707 return *int_at_addr(which);
a61af66fc99e Initial load duke parents: diff changeset	708 }
a61af66fc99e Initial load duke parents: diff changeset	709
a61af66fc99e Initial load duke parents: diff changeset	710 jint string_index_at(int which) {
a61af66fc99e Initial load duke parents: diff changeset	711 assert(tag_at(which).is_string_index(), "Corrupted constant pool");
a61af66fc99e Initial load duke parents: diff changeset	712 return *int_at_addr(which);
a61af66fc99e Initial load duke parents: diff changeset	713 }
a61af66fc99e Initial load duke parents: diff changeset	714
a61af66fc99e Initial load duke parents: diff changeset	715 // Performs the LinkResolver checks
a61af66fc99e Initial load duke parents: diff changeset	716 static void verify_constant_pool_resolve(constantPoolHandle this_oop, KlassHandle klass, TRAPS);
a61af66fc99e Initial load duke parents: diff changeset	717
a61af66fc99e Initial load duke parents: diff changeset	718 // Implementation of methods that needs an exposed 'this' pointer, in order to
a61af66fc99e Initial load duke parents: diff changeset	719 // handle GC while executing the method
a61af66fc99e Initial load duke parents: diff changeset	720 static klassOop klass_at_impl(constantPoolHandle this_oop, int which, TRAPS);
a61af66fc99e Initial load duke parents: diff changeset	721 static oop string_at_impl(constantPoolHandle this_oop, int which, TRAPS);
a61af66fc99e Initial load duke parents: diff changeset	722
a61af66fc99e Initial load duke parents: diff changeset	723 // Resolve string constants (to prevent allocation during compilation)
a61af66fc99e Initial load duke parents: diff changeset	724 static void resolve_string_constants_impl(constantPoolHandle this_oop, TRAPS);
a61af66fc99e Initial load duke parents: diff changeset	725
1602 136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	726 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	727
0 a61af66fc99e Initial load duke parents: diff changeset	728 public:
a61af66fc99e Initial load duke parents: diff changeset	729 // Merging constantPoolOop support:
a61af66fc99e Initial load duke parents: diff changeset	730 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	731 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	732 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	733 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	734 }
dad31fc330cd 7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute jrose parents: 1972 diff changeset	735 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	736 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	737 int find_matching_entry(int pattern_i, constantPoolHandle search_cp, TRAPS);
a61af66fc99e Initial load duke parents: diff changeset	738 int orig_length() const { return _orig_length; }
a61af66fc99e Initial load duke parents: diff changeset	739 void set_orig_length(int orig_length) { _orig_length = orig_length; }
a61af66fc99e Initial load duke parents: diff changeset	740
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	741 // 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	742 // when the holder class is unloaded
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	743 void unreference_symbols();
0 a61af66fc99e Initial load duke parents: diff changeset	744
a61af66fc99e Initial load duke parents: diff changeset	745 // JVMTI accesss - GetConstantPool, RetransformClasses, ...
a61af66fc99e Initial load duke parents: diff changeset	746 friend class JvmtiConstantPoolReconstituter;
a61af66fc99e Initial load duke parents: diff changeset	747
a61af66fc99e Initial load duke parents: diff changeset	748 private:
a61af66fc99e Initial load duke parents: diff changeset	749 jint cpool_entry_size(jint idx);
a61af66fc99e Initial load duke parents: diff changeset	750 jint hash_entries_to(SymbolHashMap symmap, SymbolHashMap classmap);
a61af66fc99e Initial load duke parents: diff changeset	751
a61af66fc99e Initial load duke parents: diff changeset	752 // Copy cpool bytes into byte array.
a61af66fc99e Initial load duke parents: diff changeset	753 // Returns:
a61af66fc99e Initial load duke parents: diff changeset	754 // int > 0, count of the raw cpool bytes that have been copied
a61af66fc99e Initial load duke parents: diff changeset	755 // 0, OutOfMemory error
a61af66fc99e Initial load duke parents: diff changeset	756 // -1, Internal error
a61af66fc99e Initial load duke parents: diff changeset	757 int copy_cpool_bytes(int cpool_size,
a61af66fc99e Initial load duke parents: diff changeset	758 SymbolHashMap* tbl,
a61af66fc99e Initial load duke parents: diff changeset	759 unsigned char *bytes);
a61af66fc99e Initial load duke parents: diff changeset	760 };
a61af66fc99e Initial load duke parents: diff changeset	761
a61af66fc99e Initial load duke parents: diff changeset	762 class SymbolHashMapEntry : public CHeapObj {
a61af66fc99e Initial load duke parents: diff changeset	763 private:
a61af66fc99e Initial load duke parents: diff changeset	764 unsigned int _hash; // 32-bit hash for item
a61af66fc99e Initial load duke parents: diff changeset	765 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	766 Symbol* _symbol; // 1-st part of the mapping: symbol => value
0 a61af66fc99e Initial load duke parents: diff changeset	767 u2 _value; // 2-nd part of the mapping: symbol => value
a61af66fc99e Initial load duke parents: diff changeset	768
a61af66fc99e Initial load duke parents: diff changeset	769 public:
a61af66fc99e Initial load duke parents: diff changeset	770 unsigned int hash() const { return _hash; }
a61af66fc99e Initial load duke parents: diff changeset	771 void set_hash(unsigned int hash) { _hash = hash; }
a61af66fc99e Initial load duke parents: diff changeset	772
a61af66fc99e Initial load duke parents: diff changeset	773 SymbolHashMapEntry* next() const { return _next; }
a61af66fc99e Initial load duke parents: diff changeset	774 void set_next(SymbolHashMapEntry* next) { _next = next; }
a61af66fc99e Initial load duke parents: diff changeset	775
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	776 Symbol* symbol() const { return _symbol; }
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	777 void set_symbol(Symbol* sym) { _symbol = sym; }
0 a61af66fc99e Initial load duke parents: diff changeset	778
a61af66fc99e Initial load duke parents: diff changeset	779 u2 value() const { return _value; }
a61af66fc99e Initial load duke parents: diff changeset	780 void set_value(u2 value) { _value = value; }
a61af66fc99e Initial load duke parents: diff changeset	781
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	782 SymbolHashMapEntry(unsigned int hash, Symbol* symbol, u2 value)
0 a61af66fc99e Initial load duke parents: diff changeset	783 : _hash(hash), _symbol(symbol), _value(value), _next(NULL) {}
a61af66fc99e Initial load duke parents: diff changeset	784
a61af66fc99e Initial load duke parents: diff changeset	785 }; // End SymbolHashMapEntry class
a61af66fc99e Initial load duke parents: diff changeset	786
a61af66fc99e Initial load duke parents: diff changeset	787
a61af66fc99e Initial load duke parents: diff changeset	788 class SymbolHashMapBucket : public CHeapObj {
a61af66fc99e Initial load duke parents: diff changeset	789
a61af66fc99e Initial load duke parents: diff changeset	790 private:
a61af66fc99e Initial load duke parents: diff changeset	791 SymbolHashMapEntry* _entry;
a61af66fc99e Initial load duke parents: diff changeset	792
a61af66fc99e Initial load duke parents: diff changeset	793 public:
a61af66fc99e Initial load duke parents: diff changeset	794 SymbolHashMapEntry* entry() const { return _entry; }
a61af66fc99e Initial load duke parents: diff changeset	795 void set_entry(SymbolHashMapEntry* entry) { _entry = entry; }
a61af66fc99e Initial load duke parents: diff changeset	796 void clear() { _entry = NULL; }
a61af66fc99e Initial load duke parents: diff changeset	797
a61af66fc99e Initial load duke parents: diff changeset	798 }; // End SymbolHashMapBucket class
a61af66fc99e Initial load duke parents: diff changeset	799
a61af66fc99e Initial load duke parents: diff changeset	800
a61af66fc99e Initial load duke parents: diff changeset	801 class SymbolHashMap: public CHeapObj {
a61af66fc99e Initial load duke parents: diff changeset	802
a61af66fc99e Initial load duke parents: diff changeset	803 private:
a61af66fc99e Initial load duke parents: diff changeset	804 // Default number of entries in the table
a61af66fc99e Initial load duke parents: diff changeset	805 enum SymbolHashMap_Constants {
a61af66fc99e Initial load duke parents: diff changeset	806 _Def_HashMap_Size = 256
a61af66fc99e Initial load duke parents: diff changeset	807 };
a61af66fc99e Initial load duke parents: diff changeset	808
a61af66fc99e Initial load duke parents: diff changeset	809 int _table_size;
a61af66fc99e Initial load duke parents: diff changeset	810 SymbolHashMapBucket* _buckets;
a61af66fc99e Initial load duke parents: diff changeset	811
a61af66fc99e Initial load duke parents: diff changeset	812 void initialize_table(int table_size) {
a61af66fc99e Initial load duke parents: diff changeset	813 _table_size = table_size;
a61af66fc99e Initial load duke parents: diff changeset	814 _buckets = NEW_C_HEAP_ARRAY(SymbolHashMapBucket, table_size);
a61af66fc99e Initial load duke parents: diff changeset	815 for (int index = 0; index < table_size; index++) {
a61af66fc99e Initial load duke parents: diff changeset	816 _buckets[index].clear();
a61af66fc99e Initial load duke parents: diff changeset	817 }
a61af66fc99e Initial load duke parents: diff changeset	818 }
a61af66fc99e Initial load duke parents: diff changeset	819
a61af66fc99e Initial load duke parents: diff changeset	820 public:
a61af66fc99e Initial load duke parents: diff changeset	821
a61af66fc99e Initial load duke parents: diff changeset	822 int table_size() const { return _table_size; }
a61af66fc99e Initial load duke parents: diff changeset	823
a61af66fc99e Initial load duke parents: diff changeset	824 SymbolHashMap() { initialize_table(_Def_HashMap_Size); }
a61af66fc99e Initial load duke parents: diff changeset	825 SymbolHashMap(int table_size) { initialize_table(table_size); }
a61af66fc99e Initial load duke parents: diff changeset	826
a61af66fc99e Initial load duke parents: diff changeset	827 // hash P(31) from Kernighan & Ritchie
a61af66fc99e Initial load duke parents: diff changeset	828 static unsigned int compute_hash(const char* str, int len) {
a61af66fc99e Initial load duke parents: diff changeset	829 unsigned int hash = 0;
a61af66fc99e Initial load duke parents: diff changeset	830 while (len-- > 0) {
a61af66fc99e Initial load duke parents: diff changeset	831 hash = 31hash + (unsigned) str;
a61af66fc99e Initial load duke parents: diff changeset	832 str++;
a61af66fc99e Initial load duke parents: diff changeset	833 }
a61af66fc99e Initial load duke parents: diff changeset	834 return hash;
a61af66fc99e Initial load duke parents: diff changeset	835 }
a61af66fc99e Initial load duke parents: diff changeset	836
a61af66fc99e Initial load duke parents: diff changeset	837 SymbolHashMapEntry* bucket(int i) {
a61af66fc99e Initial load duke parents: diff changeset	838 return _buckets[i].entry();
a61af66fc99e Initial load duke parents: diff changeset	839 }
a61af66fc99e Initial load duke parents: diff changeset	840
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	841 void add_entry(Symbol* sym, u2 value);
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	842 SymbolHashMapEntry* find_entry(Symbol* sym);
0 a61af66fc99e Initial load duke parents: diff changeset	843
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	844 u2 symbol_to_value(Symbol* sym) {
0 a61af66fc99e Initial load duke parents: diff changeset	845 SymbolHashMapEntry *entry = find_entry(sym);
a61af66fc99e Initial load duke parents: diff changeset	846 return (entry == NULL) ? 0 : entry->value();
a61af66fc99e Initial load duke parents: diff changeset	847 }
a61af66fc99e Initial load duke parents: diff changeset	848
a61af66fc99e Initial load duke parents: diff changeset	849 ~SymbolHashMap() {
a61af66fc99e Initial load duke parents: diff changeset	850 SymbolHashMapEntry* next;
a61af66fc99e Initial load duke parents: diff changeset	851 for (int i = 0; i < _table_size; i++) {
a61af66fc99e Initial load duke parents: diff changeset	852 for (SymbolHashMapEntry* cur = bucket(i); cur != NULL; cur = next) {
a61af66fc99e Initial load duke parents: diff changeset	853 next = cur->next();
a61af66fc99e Initial load duke parents: diff changeset	854 delete(cur);
a61af66fc99e Initial load duke parents: diff changeset	855 }
a61af66fc99e Initial load duke parents: diff changeset	856 }
a61af66fc99e Initial load duke parents: diff changeset	857 delete _buckets;
a61af66fc99e Initial load duke parents: diff changeset	858 }
a61af66fc99e Initial load duke parents: diff changeset	859 }; // End SymbolHashMap class
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1913 diff changeset	860
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1913 diff changeset	861 #endif // SHARE_VM_OOPS_CONSTANTPOOLOOP_HPP

Mercurial > hg > truffle

annotate src/share/vm/oops/constantPoolOop.hpp @ 3762:5c0a3c1858b1