Mercurial > hg > truffle
annotate src/share/vm/oops/constantPool.hpp @ 6862:8a5ea0a9ccc4
7127708: G1: change task num types from int to uint in concurrent mark
Summary: Change the type of various task num fields, parameters etc to unsigned and rename them to be more consistent with the other collectors. Code changes were also reviewed by Vitaly Davidovich.
Reviewed-by: johnc
Contributed-by: Kaushik Srenevasan <kaushik@twitter.com>
author | johnc |
---|---|
date | Sat, 06 Oct 2012 01:17:44 -0700 |
parents | f6b0eb4e44cf |
children | 6e5a59a8e4a7 |
rev | line source |
---|---|
0 | 1 /* |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2 * Copyright (c) 1997, 2012, 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" | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
29 #include "oops/cpCache.hpp" |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
30 #include "oops/objArrayOop.hpp" |
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2011
diff
changeset
|
31 #include "oops/symbol.hpp" |
1972 | 32 #include "oops/typeArrayOop.hpp" |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
33 #include "runtime/handles.hpp" |
1972 | 34 #include "utilities/constantTag.hpp" |
35 #ifdef TARGET_ARCH_x86 | |
36 # include "bytes_x86.hpp" | |
37 #endif | |
38 #ifdef TARGET_ARCH_sparc | |
39 # include "bytes_sparc.hpp" | |
40 #endif | |
41 #ifdef TARGET_ARCH_zero | |
42 # include "bytes_zero.hpp" | |
43 #endif | |
2192
b92c45f2bc75
7016023: Enable building ARM and PPC from src/closed repository
bobv
parents:
2177
diff
changeset
|
44 #ifdef TARGET_ARCH_arm |
b92c45f2bc75
7016023: Enable building ARM and PPC from src/closed repository
bobv
parents:
2177
diff
changeset
|
45 # include "bytes_arm.hpp" |
b92c45f2bc75
7016023: Enable building ARM and PPC from src/closed repository
bobv
parents:
2177
diff
changeset
|
46 #endif |
b92c45f2bc75
7016023: Enable building ARM and PPC from src/closed repository
bobv
parents:
2177
diff
changeset
|
47 #ifdef TARGET_ARCH_ppc |
b92c45f2bc75
7016023: Enable building ARM and PPC from src/closed repository
bobv
parents:
2177
diff
changeset
|
48 # include "bytes_ppc.hpp" |
b92c45f2bc75
7016023: Enable building ARM and PPC from src/closed repository
bobv
parents:
2177
diff
changeset
|
49 #endif |
1972 | 50 |
0 | 51 // A constantPool is an array containing class constants as described in the |
52 // class file. | |
53 // | |
54 // Most of the constant pool entries are written during class parsing, which | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
55 // is safe. For klass types, the constant pool entry is |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
56 // modified when the entry is resolved. If a klass constant pool |
0 | 57 // entry is read without a lock, only the resolved state guarantees that |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
58 // the entry in the constant pool is a klass object and not a Symbol*. |
0 | 59 |
60 class SymbolHashMap; | |
61 | |
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2011
diff
changeset
|
62 class CPSlot VALUE_OBJ_CLASS_SPEC { |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2011
diff
changeset
|
63 intptr_t _ptr; |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2011
diff
changeset
|
64 public: |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2011
diff
changeset
|
65 CPSlot(intptr_t ptr): _ptr(ptr) {} |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
66 CPSlot(Klass* ptr): _ptr((intptr_t)ptr) {} |
2177
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; } |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
70 bool is_resolved() { return (_ptr & 1) == 0; } |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
71 bool is_unresolved() { return (_ptr & 1) == 1; } |
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2011
diff
changeset
|
72 |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
73 Symbol* get_symbol() { |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
74 assert(is_unresolved(), "bad call"); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
75 return (Symbol*)(_ptr & ~1); |
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2011
diff
changeset
|
76 } |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
77 Klass* get_klass() { |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
78 assert(is_resolved(), "bad call"); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
79 return (Klass*)_ptr; |
2177
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 |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
83 class ConstantPool : public Metadata { |
0 | 84 friend class VMStructs; |
85 friend class BytecodeInterpreter; // Directly extracts an oop in the pool for fast instanceof/checkcast | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
86 friend class Universe; // For null constructor |
0 | 87 private: |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
88 Array<u1>* _tags; // the tag array describing the constant pool's contents |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
89 ConstantPoolCache* _cache; // the cache holding interpreter runtime information |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
90 Klass* _pool_holder; // the corresponding class |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
91 Array<u2>* _operands; // for variable-sized (InvokeDynamic) nodes, usually empty |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
92 |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
93 // Array of resolved objects from the constant pool and map from resolved |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
94 // object index to original constant pool index |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
95 jobject _resolved_references; |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
96 Array<u2>* _reference_map; |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
97 |
431
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
196
diff
changeset
|
98 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
|
99 int _length; // number of elements in the array |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
100 |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
101 bool _on_stack; // Redefined method still executing refers to this constant pool. |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
102 |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
103 union { |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
104 // set for CDS to restore resolved references |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
105 int _resolved_reference_length; |
0 | 106 // only set to non-zero if constant pool is merged by RedefineClasses |
107 int _orig_length; | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
108 } _saved; |
0 | 109 |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
110 Monitor* _lock; |
0 | 111 |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
112 void set_tags(Array<u1>* tags) { _tags = tags; } |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
113 void tag_at_put(int which, jbyte t) { tags()->at_put(which, t); } |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
114 void release_tag_at_put(int which, jbyte t) { tags()->release_at_put(which, t); } |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
115 |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
116 void set_operands(Array<u2>* operands) { _operands = operands; } |
1913
3b2dea75431e
6984311: JSR 292 needs optional bootstrap method parameters
jrose
parents:
1910
diff
changeset
|
117 |
431
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
196
diff
changeset
|
118 enum FlagBit { |
726
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
579
diff
changeset
|
119 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
|
120 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
|
121 FB_has_preresolution = 3 |
431
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
196
diff
changeset
|
122 }; |
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
196
diff
changeset
|
123 |
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
196
diff
changeset
|
124 int flags() const { return _flags; } |
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
196
diff
changeset
|
125 void set_flags(int f) { _flags = f; } |
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
196
diff
changeset
|
126 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
|
127 void set_flag_at(FlagBit fb); |
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
196
diff
changeset
|
128 // 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
|
129 |
0 | 130 private: |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
131 intptr_t* base() const { return (intptr_t*) (((char*) this) + sizeof(ConstantPool)); } |
0 | 132 |
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2011
diff
changeset
|
133 CPSlot slot_at(int which) { |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2011
diff
changeset
|
134 assert(is_within_bounds(which), "index out of bounds"); |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
135 // Uses volatile because the klass slot changes without a lock. |
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2011
diff
changeset
|
136 volatile intptr_t adr = (intptr_t)OrderAccess::load_ptr_acquire(obj_at_addr_raw(which)); |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
137 assert(adr != 0 || which == 0, "cp entry for klass should not be zero"); |
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2011
diff
changeset
|
138 return CPSlot(adr); |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2011
diff
changeset
|
139 } |
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 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
|
142 assert(is_within_bounds(which), "index out of bounds"); |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
143 assert(s.value() != 0, "Caught something"); |
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2011
diff
changeset
|
144 *(intptr_t*)&base()[which] = s.value(); |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2011
diff
changeset
|
145 } |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
146 intptr_t* obj_at_addr_raw(int which) const { |
2177
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"); |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
148 return (intptr_t*) &base()[which]; |
2177
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 |
0 | 151 jint* int_at_addr(int which) const { |
152 assert(is_within_bounds(which), "index out of bounds"); | |
153 return (jint*) &base()[which]; | |
154 } | |
155 | |
156 jlong* long_at_addr(int which) const { | |
157 assert(is_within_bounds(which), "index out of bounds"); | |
158 return (jlong*) &base()[which]; | |
159 } | |
160 | |
161 jfloat* float_at_addr(int which) const { | |
162 assert(is_within_bounds(which), "index out of bounds"); | |
163 return (jfloat*) &base()[which]; | |
164 } | |
165 | |
166 jdouble* double_at_addr(int which) const { | |
167 assert(is_within_bounds(which), "index out of bounds"); | |
168 return (jdouble*) &base()[which]; | |
169 } | |
170 | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
171 ConstantPool(Array<u1>* tags); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
172 ConstantPool() { assert(DumpSharedSpaces || UseSharedSpaces, "only for CDS"); } |
0 | 173 public: |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
174 static ConstantPool* allocate(ClassLoaderData* loader_data, int length, TRAPS); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
175 |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
176 bool is_constantPool() const volatile { return true; } |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
177 |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
178 Array<u1>* tags() const { return _tags; } |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
179 Array<u2>* 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 |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
188 // Redefine classes support. If a method refering to this constant pool |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
189 // is on the executing stack, or as a handle in vm code, this constant pool |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
190 // can't be removed from the set of previous versions saved in the instance |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
191 // class. |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
192 bool on_stack() const { return _on_stack; } |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
193 void set_on_stack(const bool value); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
194 |
0 | 195 // Klass holding pool |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
196 Klass* pool_holder() const { return _pool_holder; } |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
197 void set_pool_holder(Klass* k) { _pool_holder = k; } |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
198 Klass** pool_holder_addr() { return &_pool_holder; } |
0 | 199 |
200 // Interpreter runtime support | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
201 ConstantPoolCache* cache() const { return _cache; } |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
202 void set_cache(ConstantPoolCache* cache){ _cache = cache; } |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
203 |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
204 // Create object cache in the constant pool |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
205 void initialize_resolved_references(ClassLoaderData* loader_data, |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
206 intStack reference_map, |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
207 int constant_pool_map_length, |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
208 TRAPS); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
209 |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
210 // resolved strings, methodHandles and callsite objects from the constant pool |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
211 objArrayOop resolved_references() const; |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
212 // mapping resolved object array indexes to cp indexes and back. |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
213 int object_to_cp_index(int index) { return _reference_map->at(index); } |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
214 int cp_to_object_index(int index); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
215 |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
216 // Invokedynamic indexes. |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
217 // They must look completely different from normal indexes. |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
218 // The main reason is that byte swapping is sometimes done on normal indexes. |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
219 // Finally, it is helpful for debugging to tell the two apart. |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
220 static bool is_invokedynamic_index(int i) { return (i < 0); } |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
221 static int decode_invokedynamic_index(int i) { assert(is_invokedynamic_index(i), ""); return ~i; } |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
222 static int encode_invokedynamic_index(int i) { assert(!is_invokedynamic_index(i), ""); return ~i; } |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
223 |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
224 |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
225 // The invokedynamic points at a CP cache entry. This entry points back |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
226 // at the original CP entry (CONSTANT_InvokeDynamic) and also (via f2) at an entry |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
227 // in the resolved_references array (which provides the appendix argument). |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
228 int invokedynamic_cp_cache_index(int index) const { |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
229 assert (is_invokedynamic_index(index), "should be a invokedynamic index"); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
230 int cache_index = decode_invokedynamic_index(index); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
231 return cache_index; |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
232 } |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
233 ConstantPoolCacheEntry* invokedynamic_cp_cache_entry_at(int index) const { |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
234 // decode index that invokedynamic points to. |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
235 int cp_cache_index = invokedynamic_cp_cache_index(index); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
236 return cache()->entry_at(cp_cache_index); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
237 } |
0 | 238 |
239 // Assembly code support | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
240 static int tags_offset_in_bytes() { return offset_of(ConstantPool, _tags); } |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
241 static int cache_offset_in_bytes() { return offset_of(ConstantPool, _cache); } |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
242 static int pool_holder_offset_in_bytes() { return offset_of(ConstantPool, _pool_holder); } |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
243 static int resolved_references_offset_in_bytes() { return offset_of(ConstantPool, _resolved_references); } |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
244 static int reference_map_offset_in_bytes() { return offset_of(ConstantPool, _reference_map); } |
0 | 245 |
246 // Storing constants | |
247 | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
248 void klass_at_put(int which, Klass* k) { |
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2011
diff
changeset
|
249 assert(k != NULL, "resolved class shouldn't be null"); |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
250 assert(is_within_bounds(which), "index out of bounds"); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
251 OrderAccess::release_store_ptr((Klass* volatile *)obj_at_addr_raw(which), k); |
0 | 252 // The interpreter assumes when the tag is stored, the klass is resolved |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
253 // and the Klass* is a klass rather than a Symbol*, so we need |
0 | 254 // hardware store ordering here. |
255 release_tag_at_put(which, JVM_CONSTANT_Class); | |
256 } | |
257 | |
258 // For temporary use while constructing constant pool | |
259 void klass_index_at_put(int which, int name_index) { | |
260 tag_at_put(which, JVM_CONSTANT_ClassIndex); | |
261 *int_at_addr(which) = name_index; | |
262 } | |
263 | |
264 // Temporary until actual use | |
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2011
diff
changeset
|
265 void unresolved_klass_at_put(int which, Symbol* s) { |
0 | 266 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
|
267 slot_at_put(which, s); |
0 | 268 } |
269 | |
1602 | 270 void method_handle_index_at_put(int which, int ref_kind, int ref_index) { |
271 tag_at_put(which, JVM_CONSTANT_MethodHandle); | |
272 *int_at_addr(which) = ((jint) ref_index<<16) | ref_kind; | |
273 } | |
274 | |
275 void method_type_index_at_put(int which, int ref_index) { | |
276 tag_at_put(which, JVM_CONSTANT_MethodType); | |
277 *int_at_addr(which) = ref_index; | |
278 } | |
279 | |
2011
dad31fc330cd
7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute
jrose
parents:
1972
diff
changeset
|
280 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
|
281 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
|
282 *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
|
283 } |
2011
dad31fc330cd
7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute
jrose
parents:
1972
diff
changeset
|
284 |
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2011
diff
changeset
|
285 void unresolved_string_at_put(int which, Symbol* s) { |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
286 release_tag_at_put(which, JVM_CONSTANT_String); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
287 *symbol_at_addr(which) = s; |
0 | 288 } |
289 | |
290 void int_at_put(int which, jint i) { | |
291 tag_at_put(which, JVM_CONSTANT_Integer); | |
292 *int_at_addr(which) = i; | |
293 } | |
294 | |
295 void long_at_put(int which, jlong l) { | |
296 tag_at_put(which, JVM_CONSTANT_Long); | |
297 // *long_at_addr(which) = l; | |
298 Bytes::put_native_u8((address)long_at_addr(which), *((u8*) &l)); | |
299 } | |
300 | |
301 void float_at_put(int which, jfloat f) { | |
302 tag_at_put(which, JVM_CONSTANT_Float); | |
303 *float_at_addr(which) = f; | |
304 } | |
305 | |
306 void double_at_put(int which, jdouble d) { | |
307 tag_at_put(which, JVM_CONSTANT_Double); | |
308 // *double_at_addr(which) = d; | |
309 // u8 temp = *(u8*) &d; | |
310 Bytes::put_native_u8((address) double_at_addr(which), *((u8*) &d)); | |
311 } | |
312 | |
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2011
diff
changeset
|
313 Symbol** symbol_at_addr(int which) const { |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2011
diff
changeset
|
314 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
|
315 return (Symbol**) &base()[which]; |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2011
diff
changeset
|
316 } |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2011
diff
changeset
|
317 |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2011
diff
changeset
|
318 void symbol_at_put(int which, Symbol* s) { |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2011
diff
changeset
|
319 assert(s->refcount() != 0, "should have nonzero refcount"); |
0 | 320 tag_at_put(which, JVM_CONSTANT_Utf8); |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
321 *symbol_at_addr(which) = s; |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
322 } |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
323 |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
324 void string_at_put(int which, int obj_index, oop str) { |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
325 resolved_references()->obj_at_put(obj_index, str); |
0 | 326 } |
327 | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
328 void set_object_tag_at(int which) { |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
329 release_tag_at_put(which, JVM_CONSTANT_Object); |
0 | 330 } |
331 | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
332 void object_at_put(int which, oop obj) { |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
333 resolved_references()->obj_at_put(cp_to_object_index(which), obj); |
1138
dd57230ba8fe
6893268: additional dynamic language related optimizations in C2
twisti
parents:
1059
diff
changeset
|
334 } |
dd57230ba8fe
6893268: additional dynamic language related optimizations in C2
twisti
parents:
1059
diff
changeset
|
335 |
0 | 336 // For temporary use while constructing constant pool |
337 void string_index_at_put(int which, int string_index) { | |
338 tag_at_put(which, JVM_CONSTANT_StringIndex); | |
339 *int_at_addr(which) = string_index; | |
340 } | |
341 | |
342 void field_at_put(int which, int class_index, int name_and_type_index) { | |
343 tag_at_put(which, JVM_CONSTANT_Fieldref); | |
344 *int_at_addr(which) = ((jint) name_and_type_index<<16) | class_index; | |
345 } | |
346 | |
347 void method_at_put(int which, int class_index, int name_and_type_index) { | |
348 tag_at_put(which, JVM_CONSTANT_Methodref); | |
349 *int_at_addr(which) = ((jint) name_and_type_index<<16) | class_index; | |
350 } | |
351 | |
352 void interface_method_at_put(int which, int class_index, int name_and_type_index) { | |
353 tag_at_put(which, JVM_CONSTANT_InterfaceMethodref); | |
354 *int_at_addr(which) = ((jint) name_and_type_index<<16) | class_index; // Not so nice | |
355 } | |
356 | |
357 void name_and_type_at_put(int which, int name_index, int signature_index) { | |
358 tag_at_put(which, JVM_CONSTANT_NameAndType); | |
359 *int_at_addr(which) = ((jint) signature_index<<16) | name_index; // Not so nice | |
360 } | |
361 | |
362 // Tag query | |
363 | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
364 constantTag tag_at(int which) const { return (constantTag)tags()->at_acquire(which); } |
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2011
diff
changeset
|
365 |
0 | 366 // Fetching constants |
367 | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
368 Klass* klass_at(int which, TRAPS) { |
0 | 369 constantPoolHandle h_this(THREAD, this); |
370 return klass_at_impl(h_this, which, CHECK_NULL); | |
371 } | |
372 | |
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2011
diff
changeset
|
373 Symbol* klass_name_at(int which); // Returns the name, w/o resolving. |
0 | 374 |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
375 Klass* resolved_klass_at(int which) { // Used by Compiler |
0 | 376 guarantee(tag_at(which).is_klass(), "Corrupted constant pool"); |
377 // Must do an acquire here in case another thread resolved the klass | |
378 // behind our back, lest we later load stale values thru the oop. | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
379 return CPSlot((Klass*)OrderAccess::load_ptr_acquire(obj_at_addr_raw(which))).get_klass(); |
0 | 380 } |
381 | |
382 // 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
|
383 Symbol* unresolved_klass_at(int which) { // Temporary until actual use |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
384 Symbol* s = CPSlot((Symbol*)OrderAccess::load_ptr_acquire(obj_at_addr_raw(which))).get_symbol(); |
0 | 385 // check that the klass is still unresolved. |
386 assert(tag_at(which).is_unresolved_klass(), "Corrupted constant pool"); | |
387 return s; | |
388 } | |
389 | |
390 // RedefineClasses() API support: | |
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2011
diff
changeset
|
391 Symbol* klass_at_noresolve(int which) { return klass_name_at(which); } |
0 | 392 |
393 jint int_at(int which) { | |
394 assert(tag_at(which).is_int(), "Corrupted constant pool"); | |
395 return *int_at_addr(which); | |
396 } | |
397 | |
398 jlong long_at(int which) { | |
399 assert(tag_at(which).is_long(), "Corrupted constant pool"); | |
400 // return *long_at_addr(which); | |
401 u8 tmp = Bytes::get_native_u8((address)&base()[which]); | |
402 return *((jlong*)&tmp); | |
403 } | |
404 | |
405 jfloat float_at(int which) { | |
406 assert(tag_at(which).is_float(), "Corrupted constant pool"); | |
407 return *float_at_addr(which); | |
408 } | |
409 | |
410 jdouble double_at(int which) { | |
411 assert(tag_at(which).is_double(), "Corrupted constant pool"); | |
412 u8 tmp = Bytes::get_native_u8((address)&base()[which]); | |
413 return *((jdouble*)&tmp); | |
414 } | |
415 | |
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2011
diff
changeset
|
416 Symbol* symbol_at(int which) { |
0 | 417 assert(tag_at(which).is_utf8(), "Corrupted constant pool"); |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
418 return *symbol_at_addr(which); |
0 | 419 } |
420 | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
421 oop string_at(int which, int obj_index, TRAPS) { |
0 | 422 constantPoolHandle h_this(THREAD, this); |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
423 return string_at_impl(h_this, which, obj_index, THREAD); |
0 | 424 } |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
425 oop string_at(int which, TRAPS) { |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
426 int obj_index = cp_to_object_index(which); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
427 return string_at(which, obj_index, THREAD); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
428 } |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
429 |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
430 // Version that can be used before string oop array is created. |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
431 oop uncached_string_at(int which, TRAPS); |
0 | 432 |
1138
dd57230ba8fe
6893268: additional dynamic language related optimizations in C2
twisti
parents:
1059
diff
changeset
|
433 oop object_at(int which) { |
dd57230ba8fe
6893268: additional dynamic language related optimizations in C2
twisti
parents:
1059
diff
changeset
|
434 assert(tag_at(which).is_object(), "Corrupted constant pool"); |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
435 int obj_index = cp_to_object_index(which); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
436 return resolved_references()->obj_at(obj_index); |
1138
dd57230ba8fe
6893268: additional dynamic language related optimizations in C2
twisti
parents:
1059
diff
changeset
|
437 } |
dd57230ba8fe
6893268: additional dynamic language related optimizations in C2
twisti
parents:
1059
diff
changeset
|
438 |
431
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
196
diff
changeset
|
439 // 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
|
440 // a String entry. |
2416
38fea01eb669
6817525: turn on method handle functionality by default for JSR 292
twisti
parents:
2192
diff
changeset
|
441 // 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
|
442 // 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
|
443 // 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
|
444 // 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
|
445 |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
446 bool is_pseudo_string_at(int which) { |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
447 // A pseudo string is a string that doesn't have a symbol in the cpSlot |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
448 return unresolved_string_at(which) == NULL; |
431
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
196
diff
changeset
|
449 } |
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
196
diff
changeset
|
450 |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
451 oop pseudo_string_at(int which, int obj_index) { |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
452 assert(tag_at(which).is_string(), "Corrupted constant pool"); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
453 assert(unresolved_string_at(which) == NULL, "shouldn't have symbol"); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
454 oop s = resolved_references()->obj_at(obj_index); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
455 return s; |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
456 } |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
457 |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
458 void pseudo_string_at_put(int which, int obj_index, oop x) { |
2416
38fea01eb669
6817525: turn on method handle functionality by default for JSR 292
twisti
parents:
2192
diff
changeset
|
459 assert(EnableInvokeDynamic, ""); |
431
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
196
diff
changeset
|
460 set_pseudo_string(); // mark header |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
461 assert(tag_at(which).is_string(), "Corrupted constant pool"); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
462 string_at_put(which, obj_index, x); // this works just fine |
431
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
196
diff
changeset
|
463 } |
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
196
diff
changeset
|
464 |
0 | 465 // only called when we are sure a string entry is already resolved (via an |
466 // earlier string_at call. | |
467 oop resolved_string_at(int which) { | |
468 assert(tag_at(which).is_string(), "Corrupted constant pool"); | |
469 // Must do an acquire here in case another thread resolved the klass | |
470 // behind our back, lest we later load stale values thru the oop. | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
471 // we might want a volatile_obj_at in objArrayKlass. |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
472 int obj_index = cp_to_object_index(which); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
473 return resolved_references()->obj_at(obj_index); |
0 | 474 } |
475 | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
476 Symbol* unresolved_string_at(int which) { |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
477 assert(tag_at(which).is_string(), "Corrupted constant pool"); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
478 Symbol* s = *symbol_at_addr(which); |
0 | 479 return s; |
480 } | |
481 | |
482 // Returns an UTF8 for a CONSTANT_String entry at a given index. | |
483 // 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
|
484 // java_lang_Strings at resolved entries into Symbol*s |
0 | 485 // or vice versa. |
431
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
196
diff
changeset
|
486 // Caller is responsible for checking for pseudo-strings. |
0 | 487 char* string_at_noresolve(int which); |
488 | |
489 jint name_and_type_at(int which) { | |
490 assert(tag_at(which).is_name_and_type(), "Corrupted constant pool"); | |
491 return *int_at_addr(which); | |
492 } | |
493 | |
1602 | 494 int method_handle_ref_kind_at(int which) { |
495 assert(tag_at(which).is_method_handle(), "Corrupted constant pool"); | |
496 return extract_low_short_from_int(*int_at_addr(which)); // mask out unwanted ref_index bits | |
497 } | |
498 int method_handle_index_at(int which) { | |
499 assert(tag_at(which).is_method_handle(), "Corrupted constant pool"); | |
500 return extract_high_short_from_int(*int_at_addr(which)); // shift out unwanted ref_kind bits | |
501 } | |
502 int method_type_index_at(int which) { | |
503 assert(tag_at(which).is_method_type(), "Corrupted constant pool"); | |
504 return *int_at_addr(which); | |
505 } | |
506 // Derived queries: | |
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2011
diff
changeset
|
507 Symbol* method_handle_name_ref_at(int which) { |
1602 | 508 int member = method_handle_index_at(which); |
509 return impl_name_ref_at(member, true); | |
510 } | |
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2011
diff
changeset
|
511 Symbol* method_handle_signature_ref_at(int which) { |
1602 | 512 int member = method_handle_index_at(which); |
513 return impl_signature_ref_at(member, true); | |
514 } | |
515 int method_handle_klass_index_at(int which) { | |
516 int member = method_handle_index_at(which); | |
517 return impl_klass_ref_index_at(member, true); | |
518 } | |
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2011
diff
changeset
|
519 Symbol* method_type_signature_at(int which) { |
1602 | 520 int sym = method_type_index_at(which); |
521 return symbol_at(sym); | |
522 } | |
1913
3b2dea75431e
6984311: JSR 292 needs optional bootstrap method parameters
jrose
parents:
1910
diff
changeset
|
523 |
2011
dad31fc330cd
7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute
jrose
parents:
1972
diff
changeset
|
524 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
|
525 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
|
526 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
|
527 } |
2011
dad31fc330cd
7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute
jrose
parents:
1972
diff
changeset
|
528 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
|
529 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
|
530 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
|
531 } |
dad31fc330cd
7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute
jrose
parents:
1972
diff
changeset
|
532 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
|
533 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
|
534 return operand_offset_at(operands(), bootstrap_specifier_index); |
1913
3b2dea75431e
6984311: JSR 292 needs optional bootstrap method parameters
jrose
parents:
1910
diff
changeset
|
535 } |
2011
dad31fc330cd
7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute
jrose
parents:
1972
diff
changeset
|
536 // 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
|
537 // Extract a 32-bit index value from the first part. |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
538 static int operand_offset_at(Array<u2>* operands, int bootstrap_specifier_index) { |
2011
dad31fc330cd
7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute
jrose
parents:
1972
diff
changeset
|
539 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
|
540 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
|
541 // 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
|
542 // of the operands array. Make sure this index is in the first part. |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
543 DEBUG_ONLY(int second_part = build_int_from_shorts(operands->at(0), |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
544 operands->at(1))); |
2011
dad31fc330cd
7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute
jrose
parents:
1972
diff
changeset
|
545 assert(second_part == 0 || n+2 <= second_part, "oob (2)"); |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
546 int offset = build_int_from_shorts(operands->at(n+0), |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
547 operands->at(n+1)); |
2011
dad31fc330cd
7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute
jrose
parents:
1972
diff
changeset
|
548 // 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
|
549 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
|
550 return offset; |
1913
3b2dea75431e
6984311: JSR 292 needs optional bootstrap method parameters
jrose
parents:
1910
diff
changeset
|
551 } |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
552 static void operand_offset_at_put(Array<u2>* operands, int bootstrap_specifier_index, int offset) { |
2011
dad31fc330cd
7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute
jrose
parents:
1972
diff
changeset
|
553 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
|
554 assert(n >= 0 && n+2 <= operands->length(), "oob"); |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
555 operands->at_put(n+0, extract_low_short_from_int(offset)); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
556 operands->at_put(n+1, extract_high_short_from_int(offset)); |
2011
dad31fc330cd
7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute
jrose
parents:
1972
diff
changeset
|
557 } |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
558 static int operand_array_length(Array<u2>* operands) { |
2011
dad31fc330cd
7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute
jrose
parents:
1972
diff
changeset
|
559 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
|
560 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
|
561 return (second_part / 2); |
1913
3b2dea75431e
6984311: JSR 292 needs optional bootstrap method parameters
jrose
parents:
1910
diff
changeset
|
562 } |
3b2dea75431e
6984311: JSR 292 needs optional bootstrap method parameters
jrose
parents:
1910
diff
changeset
|
563 |
2011
dad31fc330cd
7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute
jrose
parents:
1972
diff
changeset
|
564 #ifdef ASSERT |
dad31fc330cd
7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute
jrose
parents:
1972
diff
changeset
|
565 // operand tuples fit together exactly, end to end |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
566 static int operand_limit_at(Array<u2>* operands, int bootstrap_specifier_index) { |
2011
dad31fc330cd
7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute
jrose
parents:
1972
diff
changeset
|
567 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
|
568 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
|
569 return operands->length(); |
dad31fc330cd
7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute
jrose
parents:
1972
diff
changeset
|
570 else |
dad31fc330cd
7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute
jrose
parents:
1972
diff
changeset
|
571 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
|
572 } |
dad31fc330cd
7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute
jrose
parents:
1972
diff
changeset
|
573 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
|
574 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
|
575 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
|
576 } |
dad31fc330cd
7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute
jrose
parents:
1972
diff
changeset
|
577 #endif //ASSERT |
dad31fc330cd
7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute
jrose
parents:
1972
diff
changeset
|
578 |
dad31fc330cd
7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute
jrose
parents:
1972
diff
changeset
|
579 // 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
|
580 enum { |
3b2dea75431e
6984311: JSR 292 needs optional bootstrap method parameters
jrose
parents:
1910
diff
changeset
|
581 _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
|
582 _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
|
583 _indy_argv_offset = 2 // u2 argv[argc] |
1913
3b2dea75431e
6984311: JSR 292 needs optional bootstrap method parameters
jrose
parents:
1910
diff
changeset
|
584 }; |
1660
083fde3b838e
6964498: JSR 292 invokedynamic sites need local bootstrap methods
jrose
parents:
1602
diff
changeset
|
585 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
|
586 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
|
587 int op_base = invoke_dynamic_operand_base(which); |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
588 return operands()->at(op_base + _indy_bsm_offset); |
1913
3b2dea75431e
6984311: JSR 292 needs optional bootstrap method parameters
jrose
parents:
1910
diff
changeset
|
589 } |
3b2dea75431e
6984311: JSR 292 needs optional bootstrap method parameters
jrose
parents:
1910
diff
changeset
|
590 int invoke_dynamic_argument_count_at(int which) { |
3b2dea75431e
6984311: JSR 292 needs optional bootstrap method parameters
jrose
parents:
1910
diff
changeset
|
591 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
|
592 int op_base = invoke_dynamic_operand_base(which); |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
593 int argc = operands()->at(op_base + _indy_argc_offset); |
2011
dad31fc330cd
7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute
jrose
parents:
1972
diff
changeset
|
594 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
|
595 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
|
596 assert(end_offset == next_offset, "matched ending"); |
1913
3b2dea75431e
6984311: JSR 292 needs optional bootstrap method parameters
jrose
parents:
1910
diff
changeset
|
597 return argc; |
3b2dea75431e
6984311: JSR 292 needs optional bootstrap method parameters
jrose
parents:
1910
diff
changeset
|
598 } |
3b2dea75431e
6984311: JSR 292 needs optional bootstrap method parameters
jrose
parents:
1910
diff
changeset
|
599 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
|
600 int op_base = invoke_dynamic_operand_base(which); |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
601 DEBUG_ONLY(int argc = operands()->at(op_base + _indy_argc_offset)); |
2011
dad31fc330cd
7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute
jrose
parents:
1972
diff
changeset
|
602 assert((uint)j < (uint)argc, "oob"); |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
603 return operands()->at(op_base + _indy_argv_offset + j); |
1660
083fde3b838e
6964498: JSR 292 invokedynamic sites need local bootstrap methods
jrose
parents:
1602
diff
changeset
|
604 } |
1602 | 605 |
726
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
579
diff
changeset
|
606 // 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
|
607 // 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
|
608 // directly from the bytecode. |
1059
389049f3f393
6858164: invokedynamic code needs some cleanup (post-6655638)
jrose
parents:
726
diff
changeset
|
609 // 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
|
610 // actually rewritten constant pool cache indices. |
1059
389049f3f393
6858164: invokedynamic code needs some cleanup (post-6655638)
jrose
parents:
726
diff
changeset
|
611 // The routine remap_instruction_operand_from_cache manages the adjustment |
389049f3f393
6858164: invokedynamic code needs some cleanup (post-6655638)
jrose
parents:
726
diff
changeset
|
612 // of these values back to constant pool indices. |
726
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
579
diff
changeset
|
613 |
1059
389049f3f393
6858164: invokedynamic code needs some cleanup (post-6655638)
jrose
parents:
726
diff
changeset
|
614 // There are also "uncached" versions which do not adjust the operand index; see below. |
0 | 615 |
1910
d1896d1dda3e
6981788: GC map generator sometimes picks up the wrong kind of instruction operand
jrose
parents:
1660
diff
changeset
|
616 // 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
|
617 // 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
|
618 // 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
|
619 // 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
|
620 |
0 | 621 // Lookup for entries consisting of (klass_index, name_and_type index) |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
622 Klass* klass_ref_at(int which, TRAPS); |
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2011
diff
changeset
|
623 Symbol* klass_ref_at_noresolve(int which); |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2011
diff
changeset
|
624 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
|
625 Symbol* signature_ref_at(int which) { return impl_signature_ref_at(which, false); } |
0 | 626 |
726
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
579
diff
changeset
|
627 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
|
628 int name_and_type_ref_index_at(int which) { return impl_name_and_type_ref_index_at(which, false); } |
0 | 629 |
630 // Lookup for entries consisting of (name_index, signature_index) | |
726
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
579
diff
changeset
|
631 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
|
632 int signature_ref_index_at(int which_nt); // == high-order jshort of name_and_type_at(which_nt) |
0 | 633 |
634 BasicType basic_type_for_signature_at(int which); | |
635 | |
636 // Resolve string constants (to prevent allocation during compilation) | |
637 void resolve_string_constants(TRAPS) { | |
638 constantPoolHandle h_this(THREAD, this); | |
639 resolve_string_constants_impl(h_this, CHECK); | |
640 } | |
641 | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
642 // CDS support |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
643 void remove_unshareable_info(); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
644 void restore_unshareable_info(TRAPS); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
645 bool resolve_class_constants(TRAPS); |
6733
fa6e618671d7
7195867: NPG: SAJDI tests fail with sun.jvm.hotspot.types.WrongTypeException: No suitable match for type
coleenp
parents:
6725
diff
changeset
|
646 // The ConstantPool vtable is restored by this call when the ConstantPool is |
fa6e618671d7
7195867: NPG: SAJDI tests fail with sun.jvm.hotspot.types.WrongTypeException: No suitable match for type
coleenp
parents:
6725
diff
changeset
|
647 // in the shared archive. See patch_klass_vtables() in metaspaceShared.cpp for |
fa6e618671d7
7195867: NPG: SAJDI tests fail with sun.jvm.hotspot.types.WrongTypeException: No suitable match for type
coleenp
parents:
6725
diff
changeset
|
648 // all the gory details. SA, dtrace and pstack helpers distinguish metadata |
fa6e618671d7
7195867: NPG: SAJDI tests fail with sun.jvm.hotspot.types.WrongTypeException: No suitable match for type
coleenp
parents:
6725
diff
changeset
|
649 // by their vtable. |
fa6e618671d7
7195867: NPG: SAJDI tests fail with sun.jvm.hotspot.types.WrongTypeException: No suitable match for type
coleenp
parents:
6725
diff
changeset
|
650 void restore_vtable() { guarantee(is_constantPool(), "vtable restored by this call"); } |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
651 |
1913
3b2dea75431e
6984311: JSR 292 needs optional bootstrap method parameters
jrose
parents:
1910
diff
changeset
|
652 private: |
3b2dea75431e
6984311: JSR 292 needs optional bootstrap method parameters
jrose
parents:
1910
diff
changeset
|
653 enum { _no_index_sentinel = -1, _possible_index_sentinel = -2 }; |
3b2dea75431e
6984311: JSR 292 needs optional bootstrap method parameters
jrose
parents:
1910
diff
changeset
|
654 public: |
3b2dea75431e
6984311: JSR 292 needs optional bootstrap method parameters
jrose
parents:
1910
diff
changeset
|
655 |
1602 | 656 // Resolve late bound constants. |
657 oop resolve_constant_at(int index, TRAPS) { | |
658 constantPoolHandle h_this(THREAD, this); | |
1913
3b2dea75431e
6984311: JSR 292 needs optional bootstrap method parameters
jrose
parents:
1910
diff
changeset
|
659 return resolve_constant_at_impl(h_this, index, _no_index_sentinel, THREAD); |
1602 | 660 } |
661 | |
662 oop resolve_cached_constant_at(int cache_index, TRAPS) { | |
663 constantPoolHandle h_this(THREAD, this); | |
1913
3b2dea75431e
6984311: JSR 292 needs optional bootstrap method parameters
jrose
parents:
1910
diff
changeset
|
664 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
|
665 } |
3b2dea75431e
6984311: JSR 292 needs optional bootstrap method parameters
jrose
parents:
1910
diff
changeset
|
666 |
3b2dea75431e
6984311: JSR 292 needs optional bootstrap method parameters
jrose
parents:
1910
diff
changeset
|
667 oop resolve_possibly_cached_constant_at(int pool_index, TRAPS) { |
3b2dea75431e
6984311: JSR 292 needs optional bootstrap method parameters
jrose
parents:
1910
diff
changeset
|
668 constantPoolHandle h_this(THREAD, this); |
3b2dea75431e
6984311: JSR 292 needs optional bootstrap method parameters
jrose
parents:
1910
diff
changeset
|
669 return resolve_constant_at_impl(h_this, pool_index, _possible_index_sentinel, THREAD); |
1602 | 670 } |
671 | |
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6197
diff
changeset
|
672 oop resolve_bootstrap_specifier_at(int index, TRAPS) { |
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6197
diff
changeset
|
673 constantPoolHandle h_this(THREAD, this); |
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6197
diff
changeset
|
674 return resolve_bootstrap_specifier_at_impl(h_this, index, THREAD); |
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6197
diff
changeset
|
675 } |
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6197
diff
changeset
|
676 |
0 | 677 // Klass name matches name at offset |
678 bool klass_name_at_matches(instanceKlassHandle k, int which); | |
679 | |
680 // Sizing | |
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
681 int length() const { return _length; } |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
682 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
|
683 |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
684 // 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
|
685 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
|
686 return 0 <= index && index < length(); |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
687 } |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
688 |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
689 static int header_size() { return sizeof(ConstantPool)/HeapWordSize; } |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
690 static int size(int length) { return align_object_size(header_size() + length); } |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
691 int size() const { return size(length()); } |
0 | 692 |
693 friend class ClassFileParser; | |
694 friend class SystemDictionary; | |
695 | |
696 // Used by compiler to prevent classloading. | |
6822
f6b0eb4e44cf
7200949: JSR 292: rubybench/bench/time/bench_base64.rb fails with jruby.jar not on boot class path
twisti
parents:
6733
diff
changeset
|
697 static Method* method_at_if_loaded (constantPoolHandle this_oop, int which); |
f6b0eb4e44cf
7200949: JSR 292: rubybench/bench/time/bench_base64.rb fails with jruby.jar not on boot class path
twisti
parents:
6733
diff
changeset
|
698 static bool has_appendix_at_if_loaded (constantPoolHandle this_oop, int which); |
f6b0eb4e44cf
7200949: JSR 292: rubybench/bench/time/bench_base64.rb fails with jruby.jar not on boot class path
twisti
parents:
6733
diff
changeset
|
699 static oop appendix_at_if_loaded (constantPoolHandle this_oop, int which); |
f6b0eb4e44cf
7200949: JSR 292: rubybench/bench/time/bench_base64.rb fails with jruby.jar not on boot class path
twisti
parents:
6733
diff
changeset
|
700 static bool has_method_type_at_if_loaded (constantPoolHandle this_oop, int which); |
f6b0eb4e44cf
7200949: JSR 292: rubybench/bench/time/bench_base64.rb fails with jruby.jar not on boot class path
twisti
parents:
6733
diff
changeset
|
701 static oop method_type_at_if_loaded (constantPoolHandle this_oop, int which); |
f6b0eb4e44cf
7200949: JSR 292: rubybench/bench/time/bench_base64.rb fails with jruby.jar not on boot class path
twisti
parents:
6733
diff
changeset
|
702 static Klass* klass_at_if_loaded (constantPoolHandle this_oop, int which); |
f6b0eb4e44cf
7200949: JSR 292: rubybench/bench/time/bench_base64.rb fails with jruby.jar not on boot class path
twisti
parents:
6733
diff
changeset
|
703 static Klass* klass_ref_at_if_loaded (constantPoolHandle this_oop, int which); |
0 | 704 // Same as above - but does LinkResolving. |
6822
f6b0eb4e44cf
7200949: JSR 292: rubybench/bench/time/bench_base64.rb fails with jruby.jar not on boot class path
twisti
parents:
6733
diff
changeset
|
705 static Klass* klass_ref_at_if_loaded_check(constantPoolHandle this_oop, int which, TRAPS); |
0 | 706 |
707 // 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
|
708 // future by other Java code. These take constant pool indices rather than |
0 | 709 // 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
|
710 Symbol* uncached_klass_ref_at_noresolve(int which); |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2011
diff
changeset
|
711 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
|
712 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
|
713 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
|
714 int uncached_name_and_type_ref_index_at(int which) { return impl_name_and_type_ref_index_at(which, true); } |
0 | 715 |
716 // Sharing | |
717 int pre_resolve_shared_klasses(TRAPS); | |
718 | |
719 // Debugging | |
720 const char* printable_name_at(int which) PRODUCT_RETURN0; | |
721 | |
1565 | 722 #ifdef ASSERT |
723 enum { CPCACHE_INDEX_TAG = 0x10000 }; // helps keep CP cache indices distinct from CP indices | |
1602 | 724 #else |
725 enum { CPCACHE_INDEX_TAG = 0 }; // in product mode, this zero value is a no-op | |
1565 | 726 #endif //ASSERT |
727 | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
728 static int decode_cpcache_index(int raw_index, bool invokedynamic_ok = false) { |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
729 if (invokedynamic_ok && is_invokedynamic_index(raw_index)) |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
730 return decode_invokedynamic_index(raw_index); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
731 else |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
732 return raw_index - CPCACHE_INDEX_TAG; |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
733 } |
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6197
diff
changeset
|
734 |
0 | 735 private: |
736 | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
737 void set_resolved_references(jobject s) { _resolved_references = s; } |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
738 Array<u2>* reference_map() const { return _reference_map; } |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
739 void set_reference_map(Array<u2>* o) { _reference_map = o; } |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
740 |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
741 // patch JSR 292 resolved references after the class is linked. |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
742 void patch_resolved_references(GrowableArray<Handle>* cp_patches); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
743 |
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2011
diff
changeset
|
744 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
|
745 Symbol* impl_signature_ref_at(int which, bool uncached); |
726
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
579
diff
changeset
|
746 int impl_klass_ref_index_at(int which, bool uncached); |
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
579
diff
changeset
|
747 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
|
748 |
1565 | 749 int remap_instruction_operand_from_cache(int operand); // operand must be biased by CPCACHE_INDEX_TAG |
0 | 750 |
751 // Used while constructing constant pool (only by ClassFileParser) | |
752 jint klass_index_at(int which) { | |
753 assert(tag_at(which).is_klass_index(), "Corrupted constant pool"); | |
754 return *int_at_addr(which); | |
755 } | |
756 | |
757 jint string_index_at(int which) { | |
758 assert(tag_at(which).is_string_index(), "Corrupted constant pool"); | |
759 return *int_at_addr(which); | |
760 } | |
761 | |
762 // Performs the LinkResolver checks | |
763 static void verify_constant_pool_resolve(constantPoolHandle this_oop, KlassHandle klass, TRAPS); | |
764 | |
765 // Implementation of methods that needs an exposed 'this' pointer, in order to | |
766 // handle GC while executing the method | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
767 static Klass* klass_at_impl(constantPoolHandle this_oop, int which, TRAPS); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
768 static oop string_at_impl(constantPoolHandle this_oop, int which, int obj_index, TRAPS); |
0 | 769 |
770 // Resolve string constants (to prevent allocation during compilation) | |
771 static void resolve_string_constants_impl(constantPoolHandle this_oop, TRAPS); | |
772 | |
1602 | 773 static oop resolve_constant_at_impl(constantPoolHandle this_oop, int index, int cache_index, TRAPS); |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
774 static void save_and_throw_exception(constantPoolHandle this_oop, int which, int tag_value, TRAPS); |
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6197
diff
changeset
|
775 static oop resolve_bootstrap_specifier_at_impl(constantPoolHandle this_oop, int index, TRAPS); |
1602 | 776 |
0 | 777 public: |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
778 // Merging ConstantPool* support: |
0 | 779 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
|
780 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
|
781 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
|
782 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
|
783 } |
dad31fc330cd
7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute
jrose
parents:
1972
diff
changeset
|
784 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
|
785 static void copy_entry_to(constantPoolHandle from_cp, int from_i, constantPoolHandle to_cp, int to_i, TRAPS); |
0 | 786 int find_matching_entry(int pattern_i, constantPoolHandle search_cp, TRAPS); |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
787 int orig_length() const { return _saved._orig_length; } |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
788 void set_orig_length(int orig_length) { _saved._orig_length = orig_length; } |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
789 |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
790 void set_resolved_reference_length(int length) { _saved._resolved_reference_length = length; } |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
791 int resolved_reference_length() const { return _saved._resolved_reference_length; } |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
792 void set_lock(Monitor* lock) { _lock = lock; } |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
793 Monitor* lock() { return _lock; } |
0 | 794 |
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2011
diff
changeset
|
795 // 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
|
796 // when the holder class is unloaded |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2011
diff
changeset
|
797 void unreference_symbols(); |
0 | 798 |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
799 // Deallocate constant pool for RedefineClasses |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
800 void deallocate_contents(ClassLoaderData* loader_data); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
801 void release_C_heap_structures(); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
802 |
0 | 803 // JVMTI accesss - GetConstantPool, RetransformClasses, ... |
804 friend class JvmtiConstantPoolReconstituter; | |
805 | |
806 private: | |
807 jint cpool_entry_size(jint idx); | |
808 jint hash_entries_to(SymbolHashMap *symmap, SymbolHashMap *classmap); | |
809 | |
810 // Copy cpool bytes into byte array. | |
811 // Returns: | |
812 // int > 0, count of the raw cpool bytes that have been copied | |
813 // 0, OutOfMemory error | |
814 // -1, Internal error | |
815 int copy_cpool_bytes(int cpool_size, | |
816 SymbolHashMap* tbl, | |
817 unsigned char *bytes); | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
818 |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
819 public: |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
820 // Verify |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
821 void verify_on(outputStream* st); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
822 |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
823 // Printing |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
824 void print_on(outputStream* st) const; |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
825 void print_value_on(outputStream* st) const; |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
826 void print_entry_on(int index, outputStream* st); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
827 |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
828 const char* internal_name() const { return "{constant pool}"; } |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
829 |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
830 #ifndef PRODUCT |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
831 // Compile the world support |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
832 static void preload_and_initialize_all_classes(ConstantPool* constant_pool, TRAPS); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
833 #endif |
0 | 834 }; |
835 | |
6197 | 836 class SymbolHashMapEntry : public CHeapObj<mtSymbol> { |
0 | 837 private: |
838 unsigned int _hash; // 32-bit hash for item | |
839 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
|
840 Symbol* _symbol; // 1-st part of the mapping: symbol => value |
0 | 841 u2 _value; // 2-nd part of the mapping: symbol => value |
842 | |
843 public: | |
844 unsigned int hash() const { return _hash; } | |
845 void set_hash(unsigned int hash) { _hash = hash; } | |
846 | |
847 SymbolHashMapEntry* next() const { return _next; } | |
848 void set_next(SymbolHashMapEntry* next) { _next = next; } | |
849 | |
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2011
diff
changeset
|
850 Symbol* symbol() const { return _symbol; } |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2011
diff
changeset
|
851 void set_symbol(Symbol* sym) { _symbol = sym; } |
0 | 852 |
853 u2 value() const { return _value; } | |
854 void set_value(u2 value) { _value = value; } | |
855 | |
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2011
diff
changeset
|
856 SymbolHashMapEntry(unsigned int hash, Symbol* symbol, u2 value) |
0 | 857 : _hash(hash), _symbol(symbol), _value(value), _next(NULL) {} |
858 | |
859 }; // End SymbolHashMapEntry class | |
860 | |
861 | |
6197 | 862 class SymbolHashMapBucket : public CHeapObj<mtSymbol> { |
0 | 863 |
864 private: | |
865 SymbolHashMapEntry* _entry; | |
866 | |
867 public: | |
868 SymbolHashMapEntry* entry() const { return _entry; } | |
869 void set_entry(SymbolHashMapEntry* entry) { _entry = entry; } | |
870 void clear() { _entry = NULL; } | |
871 | |
872 }; // End SymbolHashMapBucket class | |
873 | |
874 | |
6197 | 875 class SymbolHashMap: public CHeapObj<mtSymbol> { |
0 | 876 |
877 private: | |
878 // Default number of entries in the table | |
879 enum SymbolHashMap_Constants { | |
880 _Def_HashMap_Size = 256 | |
881 }; | |
882 | |
883 int _table_size; | |
884 SymbolHashMapBucket* _buckets; | |
885 | |
886 void initialize_table(int table_size) { | |
887 _table_size = table_size; | |
6197 | 888 _buckets = NEW_C_HEAP_ARRAY(SymbolHashMapBucket, table_size, mtSymbol); |
0 | 889 for (int index = 0; index < table_size; index++) { |
890 _buckets[index].clear(); | |
891 } | |
892 } | |
893 | |
894 public: | |
895 | |
896 int table_size() const { return _table_size; } | |
897 | |
898 SymbolHashMap() { initialize_table(_Def_HashMap_Size); } | |
899 SymbolHashMap(int table_size) { initialize_table(table_size); } | |
900 | |
901 // hash P(31) from Kernighan & Ritchie | |
902 static unsigned int compute_hash(const char* str, int len) { | |
903 unsigned int hash = 0; | |
904 while (len-- > 0) { | |
905 hash = 31*hash + (unsigned) *str; | |
906 str++; | |
907 } | |
908 return hash; | |
909 } | |
910 | |
911 SymbolHashMapEntry* bucket(int i) { | |
912 return _buckets[i].entry(); | |
913 } | |
914 | |
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2011
diff
changeset
|
915 void add_entry(Symbol* sym, u2 value); |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2011
diff
changeset
|
916 SymbolHashMapEntry* find_entry(Symbol* sym); |
0 | 917 |
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2011
diff
changeset
|
918 u2 symbol_to_value(Symbol* sym) { |
0 | 919 SymbolHashMapEntry *entry = find_entry(sym); |
920 return (entry == NULL) ? 0 : entry->value(); | |
921 } | |
922 | |
923 ~SymbolHashMap() { | |
924 SymbolHashMapEntry* next; | |
925 for (int i = 0; i < _table_size; i++) { | |
926 for (SymbolHashMapEntry* cur = bucket(i); cur != NULL; cur = next) { | |
927 next = cur->next(); | |
928 delete(cur); | |
929 } | |
930 } | |
931 delete _buckets; | |
932 } | |
933 }; // End SymbolHashMap class | |
1972 | 934 |
935 #endif // SHARE_VM_OOPS_CONSTANTPOOLOOP_HPP |