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