Mercurial > hg > graal-compiler
annotate src/share/vm/oops/constantPool.hpp @ 10185:d50cc62e94ff
8012715: G1: GraphKit accesses PtrQueue::_index as int but is size_t
Summary: In graphKit INT operations were generated to access PtrQueue::_index which has type size_t. This is 64 bit on 64-bit machines. No problems occur on little endian machines as long as the index fits into 32 bit, but on big endian machines the upper part is read, which is zero. This leads to unnecessary branches to the slow path in the runtime.
Reviewed-by: twisti, johnc
Contributed-by: Martin Doerr <martin.doerr@sap.com>
author | johnc |
---|---|
date | Wed, 24 Apr 2013 14:48:43 -0700 |
parents | f16e75e0cf11 |
children | 5fc51c1ecdeb 15a99ca4ee34 |
rev | line source |
---|---|
0 | 1 /* |
7624
b14da2e6f2dc
7174978: NPG: Fix bactrace builder for class redefinition
coleenp
parents:
6940
diff
changeset
|
2 * Copyright (c) 1997, 2013, 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 |
7956 | 83 class KlassSizeStats; |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
84 class ConstantPool : public Metadata { |
0 | 85 friend class VMStructs; |
86 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
|
87 friend class Universe; // For null constructor |
0 | 88 private: |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
89 Array<u1>* _tags; // the tag array describing the constant pool's contents |
6940
18fb7da42534
8000725: NPG: method_holder() and pool_holder() and pool_holder field should be InstanceKlass
coleenp
parents:
6840
diff
changeset
|
90 ConstantPoolCache* _cache; // the cache holding interpreter runtime information |
18fb7da42534
8000725: NPG: method_holder() and pool_holder() and pool_holder field should be InstanceKlass
coleenp
parents:
6840
diff
changeset
|
91 InstanceKlass* _pool_holder; // the corresponding class |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
92 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
|
93 |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
94 // 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
|
95 // object index to original constant pool index |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
96 jobject _resolved_references; |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
97 Array<u2>* _reference_map; |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
98 |
7949
5daaddd917a1
8006040: NPG: on_stack processing wastes space in ConstantPool
coleenp
parents:
7625
diff
changeset
|
99 enum { |
8104 | 100 _has_preresolution = 1, // Flags |
101 _on_stack = 2 | |
7949
5daaddd917a1
8006040: NPG: on_stack processing wastes space in ConstantPool
coleenp
parents:
7625
diff
changeset
|
102 }; |
5daaddd917a1
8006040: NPG: on_stack processing wastes space in ConstantPool
coleenp
parents:
7625
diff
changeset
|
103 |
5daaddd917a1
8006040: NPG: on_stack processing wastes space in ConstantPool
coleenp
parents:
7625
diff
changeset
|
104 int _flags; // old fashioned bit twiddling |
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
105 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
|
106 |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
107 union { |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
108 // set for CDS to restore resolved references |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
109 int _resolved_reference_length; |
7624
b14da2e6f2dc
7174978: NPG: Fix bactrace builder for class redefinition
coleenp
parents:
6940
diff
changeset
|
110 // keeps version number for redefined classes (used in backtrace) |
b14da2e6f2dc
7174978: NPG: Fix bactrace builder for class redefinition
coleenp
parents:
6940
diff
changeset
|
111 int _version; |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
112 } _saved; |
0 | 113 |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
114 Monitor* _lock; |
0 | 115 |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
116 void set_tags(Array<u1>* tags) { _tags = tags; } |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
117 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
|
118 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
|
119 |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
120 void set_operands(Array<u2>* operands) { _operands = operands; } |
1913
3b2dea75431e
6984311: JSR 292 needs optional bootstrap method parameters
jrose
parents:
1910
diff
changeset
|
121 |
7949
5daaddd917a1
8006040: NPG: on_stack processing wastes space in ConstantPool
coleenp
parents:
7625
diff
changeset
|
122 int flags() const { return _flags; } |
5daaddd917a1
8006040: NPG: on_stack processing wastes space in ConstantPool
coleenp
parents:
7625
diff
changeset
|
123 void set_flags(int f) { _flags = f; } |
431
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
196
diff
changeset
|
124 |
0 | 125 private: |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
126 intptr_t* base() const { return (intptr_t*) (((char*) this) + sizeof(ConstantPool)); } |
0 | 127 |
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2011
diff
changeset
|
128 CPSlot slot_at(int which) { |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2011
diff
changeset
|
129 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
|
130 // 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
|
131 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
|
132 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
|
133 return CPSlot(adr); |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2011
diff
changeset
|
134 } |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2011
diff
changeset
|
135 |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2011
diff
changeset
|
136 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
|
137 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
|
138 assert(s.value() != 0, "Caught something"); |
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2011
diff
changeset
|
139 *(intptr_t*)&base()[which] = s.value(); |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2011
diff
changeset
|
140 } |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
141 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
|
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 return (intptr_t*) &base()[which]; |
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2011
diff
changeset
|
144 } |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2011
diff
changeset
|
145 |
0 | 146 jint* int_at_addr(int which) const { |
147 assert(is_within_bounds(which), "index out of bounds"); | |
148 return (jint*) &base()[which]; | |
149 } | |
150 | |
151 jlong* long_at_addr(int which) const { | |
152 assert(is_within_bounds(which), "index out of bounds"); | |
153 return (jlong*) &base()[which]; | |
154 } | |
155 | |
156 jfloat* float_at_addr(int which) const { | |
157 assert(is_within_bounds(which), "index out of bounds"); | |
158 return (jfloat*) &base()[which]; | |
159 } | |
160 | |
161 jdouble* double_at_addr(int which) const { | |
162 assert(is_within_bounds(which), "index out of bounds"); | |
163 return (jdouble*) &base()[which]; | |
164 } | |
165 | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
166 ConstantPool(Array<u1>* tags); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
167 ConstantPool() { assert(DumpSharedSpaces || UseSharedSpaces, "only for CDS"); } |
0 | 168 public: |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
169 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
|
170 |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
171 bool is_constantPool() const volatile { return true; } |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
172 |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
173 Array<u1>* tags() const { return _tags; } |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
174 Array<u2>* operands() const { return _operands; } |
0 | 175 |
7949
5daaddd917a1
8006040: NPG: on_stack processing wastes space in ConstantPool
coleenp
parents:
7625
diff
changeset
|
176 bool has_preresolution() const { return (_flags & _has_preresolution) != 0; } |
5daaddd917a1
8006040: NPG: on_stack processing wastes space in ConstantPool
coleenp
parents:
7625
diff
changeset
|
177 void set_has_preresolution() { _flags |= _has_preresolution; } |
431
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
196
diff
changeset
|
178 |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
179 // 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
|
180 // 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
|
181 // 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
|
182 // class. |
7949
5daaddd917a1
8006040: NPG: on_stack processing wastes space in ConstantPool
coleenp
parents:
7625
diff
changeset
|
183 bool on_stack() const { return (_flags &_on_stack) != 0; } |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
184 void set_on_stack(const bool value); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
185 |
0 | 186 // Klass holding pool |
6940
18fb7da42534
8000725: NPG: method_holder() and pool_holder() and pool_holder field should be InstanceKlass
coleenp
parents:
6840
diff
changeset
|
187 InstanceKlass* pool_holder() const { return _pool_holder; } |
18fb7da42534
8000725: NPG: method_holder() and pool_holder() and pool_holder field should be InstanceKlass
coleenp
parents:
6840
diff
changeset
|
188 void set_pool_holder(InstanceKlass* k) { _pool_holder = k; } |
18fb7da42534
8000725: NPG: method_holder() and pool_holder() and pool_holder field should be InstanceKlass
coleenp
parents:
6840
diff
changeset
|
189 InstanceKlass** pool_holder_addr() { return &_pool_holder; } |
0 | 190 |
191 // Interpreter runtime support | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
192 ConstantPoolCache* cache() const { return _cache; } |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
193 void set_cache(ConstantPoolCache* cache){ _cache = cache; } |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
194 |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
195 // Create object cache in the constant pool |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
196 void initialize_resolved_references(ClassLoaderData* loader_data, |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
197 intStack reference_map, |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
198 int constant_pool_map_length, |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
199 TRAPS); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
200 |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
201 // 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
|
202 objArrayOop resolved_references() const; |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
203 // 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
|
204 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
|
205 int cp_to_object_index(int index); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
206 |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
207 // Invokedynamic indexes. |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
208 // They must look completely different from normal indexes. |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
209 // 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
|
210 // 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
|
211 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
|
212 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
|
213 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
|
214 |
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 // 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
|
217 // 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
|
218 // 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
|
219 int invokedynamic_cp_cache_index(int index) const { |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
220 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
|
221 int cache_index = decode_invokedynamic_index(index); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
222 return cache_index; |
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 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
|
225 // decode index that invokedynamic points to. |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
226 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
|
227 return cache()->entry_at(cp_cache_index); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
228 } |
0 | 229 |
230 // Assembly code support | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
231 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
|
232 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
|
233 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
|
234 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
|
235 static int reference_map_offset_in_bytes() { return offset_of(ConstantPool, _reference_map); } |
0 | 236 |
237 // Storing constants | |
238 | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
239 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
|
240 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
|
241 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
|
242 OrderAccess::release_store_ptr((Klass* volatile *)obj_at_addr_raw(which), k); |
0 | 243 // 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
|
244 // and the Klass* is a klass rather than a Symbol*, so we need |
0 | 245 // hardware store ordering here. |
246 release_tag_at_put(which, JVM_CONSTANT_Class); | |
247 } | |
248 | |
249 // For temporary use while constructing constant pool | |
250 void klass_index_at_put(int which, int name_index) { | |
251 tag_at_put(which, JVM_CONSTANT_ClassIndex); | |
252 *int_at_addr(which) = name_index; | |
253 } | |
254 | |
255 // Temporary until actual use | |
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2011
diff
changeset
|
256 void unresolved_klass_at_put(int which, Symbol* s) { |
0 | 257 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
|
258 slot_at_put(which, s); |
0 | 259 } |
260 | |
1602 | 261 void method_handle_index_at_put(int which, int ref_kind, int ref_index) { |
262 tag_at_put(which, JVM_CONSTANT_MethodHandle); | |
263 *int_at_addr(which) = ((jint) ref_index<<16) | ref_kind; | |
264 } | |
265 | |
266 void method_type_index_at_put(int which, int ref_index) { | |
267 tag_at_put(which, JVM_CONSTANT_MethodType); | |
268 *int_at_addr(which) = ref_index; | |
269 } | |
270 | |
2011
dad31fc330cd
7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute
jrose
parents:
1972
diff
changeset
|
271 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
|
272 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
|
273 *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
|
274 } |
2011
dad31fc330cd
7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute
jrose
parents:
1972
diff
changeset
|
275 |
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2011
diff
changeset
|
276 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
|
277 release_tag_at_put(which, JVM_CONSTANT_String); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
278 *symbol_at_addr(which) = s; |
0 | 279 } |
280 | |
281 void int_at_put(int which, jint i) { | |
282 tag_at_put(which, JVM_CONSTANT_Integer); | |
283 *int_at_addr(which) = i; | |
284 } | |
285 | |
286 void long_at_put(int which, jlong l) { | |
287 tag_at_put(which, JVM_CONSTANT_Long); | |
288 // *long_at_addr(which) = l; | |
289 Bytes::put_native_u8((address)long_at_addr(which), *((u8*) &l)); | |
290 } | |
291 | |
292 void float_at_put(int which, jfloat f) { | |
293 tag_at_put(which, JVM_CONSTANT_Float); | |
294 *float_at_addr(which) = f; | |
295 } | |
296 | |
297 void double_at_put(int which, jdouble d) { | |
298 tag_at_put(which, JVM_CONSTANT_Double); | |
299 // *double_at_addr(which) = d; | |
300 // u8 temp = *(u8*) &d; | |
301 Bytes::put_native_u8((address) double_at_addr(which), *((u8*) &d)); | |
302 } | |
303 | |
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2011
diff
changeset
|
304 Symbol** symbol_at_addr(int which) const { |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2011
diff
changeset
|
305 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
|
306 return (Symbol**) &base()[which]; |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2011
diff
changeset
|
307 } |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2011
diff
changeset
|
308 |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2011
diff
changeset
|
309 void symbol_at_put(int which, Symbol* s) { |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2011
diff
changeset
|
310 assert(s->refcount() != 0, "should have nonzero refcount"); |
0 | 311 tag_at_put(which, JVM_CONSTANT_Utf8); |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
312 *symbol_at_addr(which) = s; |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
313 } |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
314 |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
315 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
|
316 resolved_references()->obj_at_put(obj_index, str); |
0 | 317 } |
318 | |
319 // For temporary use while constructing constant pool | |
320 void string_index_at_put(int which, int string_index) { | |
321 tag_at_put(which, JVM_CONSTANT_StringIndex); | |
322 *int_at_addr(which) = string_index; | |
323 } | |
324 | |
325 void field_at_put(int which, int class_index, int name_and_type_index) { | |
326 tag_at_put(which, JVM_CONSTANT_Fieldref); | |
327 *int_at_addr(which) = ((jint) name_and_type_index<<16) | class_index; | |
328 } | |
329 | |
330 void method_at_put(int which, int class_index, int name_and_type_index) { | |
331 tag_at_put(which, JVM_CONSTANT_Methodref); | |
332 *int_at_addr(which) = ((jint) name_and_type_index<<16) | class_index; | |
333 } | |
334 | |
335 void interface_method_at_put(int which, int class_index, int name_and_type_index) { | |
336 tag_at_put(which, JVM_CONSTANT_InterfaceMethodref); | |
337 *int_at_addr(which) = ((jint) name_and_type_index<<16) | class_index; // Not so nice | |
338 } | |
339 | |
340 void name_and_type_at_put(int which, int name_index, int signature_index) { | |
341 tag_at_put(which, JVM_CONSTANT_NameAndType); | |
342 *int_at_addr(which) = ((jint) signature_index<<16) | name_index; // Not so nice | |
343 } | |
344 | |
345 // Tag query | |
346 | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
347 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
|
348 |
0 | 349 // Fetching constants |
350 | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
351 Klass* klass_at(int which, TRAPS) { |
0 | 352 constantPoolHandle h_this(THREAD, this); |
353 return klass_at_impl(h_this, which, CHECK_NULL); | |
354 } | |
355 | |
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2011
diff
changeset
|
356 Symbol* klass_name_at(int which); // Returns the name, w/o resolving. |
0 | 357 |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
358 Klass* resolved_klass_at(int which) { // Used by Compiler |
0 | 359 guarantee(tag_at(which).is_klass(), "Corrupted constant pool"); |
360 // Must do an acquire here in case another thread resolved the klass | |
361 // 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
|
362 return CPSlot((Klass*)OrderAccess::load_ptr_acquire(obj_at_addr_raw(which))).get_klass(); |
0 | 363 } |
364 | |
365 // 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
|
366 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
|
367 Symbol* s = CPSlot((Symbol*)OrderAccess::load_ptr_acquire(obj_at_addr_raw(which))).get_symbol(); |
0 | 368 // check that the klass is still unresolved. |
369 assert(tag_at(which).is_unresolved_klass(), "Corrupted constant pool"); | |
370 return s; | |
371 } | |
372 | |
373 // RedefineClasses() API support: | |
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2011
diff
changeset
|
374 Symbol* klass_at_noresolve(int which) { return klass_name_at(which); } |
0 | 375 |
376 jint int_at(int which) { | |
377 assert(tag_at(which).is_int(), "Corrupted constant pool"); | |
378 return *int_at_addr(which); | |
379 } | |
380 | |
381 jlong long_at(int which) { | |
382 assert(tag_at(which).is_long(), "Corrupted constant pool"); | |
383 // return *long_at_addr(which); | |
384 u8 tmp = Bytes::get_native_u8((address)&base()[which]); | |
385 return *((jlong*)&tmp); | |
386 } | |
387 | |
388 jfloat float_at(int which) { | |
389 assert(tag_at(which).is_float(), "Corrupted constant pool"); | |
390 return *float_at_addr(which); | |
391 } | |
392 | |
393 jdouble double_at(int which) { | |
394 assert(tag_at(which).is_double(), "Corrupted constant pool"); | |
395 u8 tmp = Bytes::get_native_u8((address)&base()[which]); | |
396 return *((jdouble*)&tmp); | |
397 } | |
398 | |
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2011
diff
changeset
|
399 Symbol* symbol_at(int which) { |
0 | 400 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
|
401 return *symbol_at_addr(which); |
0 | 402 } |
403 | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
404 oop string_at(int which, int obj_index, TRAPS) { |
0 | 405 constantPoolHandle h_this(THREAD, this); |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
406 return string_at_impl(h_this, which, obj_index, THREAD); |
0 | 407 } |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
408 oop string_at(int which, TRAPS) { |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
409 int obj_index = cp_to_object_index(which); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
410 return string_at(which, obj_index, THREAD); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
411 } |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
412 |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
413 // 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
|
414 oop uncached_string_at(int which, TRAPS); |
0 | 415 |
431
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
196
diff
changeset
|
416 // 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
|
417 // a String entry. |
2416
38fea01eb669
6817525: turn on method handle functionality by default for JSR 292
twisti
parents:
2192
diff
changeset
|
418 // 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
|
419 // 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
|
420 // 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
|
421 // 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
|
422 |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
423 bool is_pseudo_string_at(int which) { |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
424 // 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
|
425 return unresolved_string_at(which) == NULL; |
431
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
196
diff
changeset
|
426 } |
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
196
diff
changeset
|
427 |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
428 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
|
429 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
|
430 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
|
431 oop s = resolved_references()->obj_at(obj_index); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
432 return s; |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
433 } |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
434 |
8104 | 435 oop pseudo_string_at(int which) { |
436 assert(tag_at(which).is_string(), "Corrupted constant pool"); | |
437 assert(unresolved_string_at(which) == NULL, "shouldn't have symbol"); | |
438 int obj_index = cp_to_object_index(which); | |
439 oop s = resolved_references()->obj_at(obj_index); | |
440 return s; | |
441 } | |
442 | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
443 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
|
444 assert(EnableInvokeDynamic, ""); |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
445 assert(tag_at(which).is_string(), "Corrupted constant pool"); |
8104 | 446 unresolved_string_at_put(which, NULL); // indicates patched string |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
447 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
|
448 } |
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
196
diff
changeset
|
449 |
0 | 450 // only called when we are sure a string entry is already resolved (via an |
451 // earlier string_at call. | |
452 oop resolved_string_at(int which) { | |
453 assert(tag_at(which).is_string(), "Corrupted constant pool"); | |
454 // Must do an acquire here in case another thread resolved the klass | |
455 // behind our back, lest we later load stale values thru the oop. | |
6831
d8ce2825b193
8000213: NPG: Should have renamed arrayKlass and typeArrayKlass
coleenp
parents:
6733
diff
changeset
|
456 // we might want a volatile_obj_at in ObjArrayKlass. |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
457 int obj_index = cp_to_object_index(which); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
458 return resolved_references()->obj_at(obj_index); |
0 | 459 } |
460 | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
461 Symbol* unresolved_string_at(int which) { |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
462 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
|
463 Symbol* s = *symbol_at_addr(which); |
0 | 464 return s; |
465 } | |
466 | |
467 // Returns an UTF8 for a CONSTANT_String entry at a given index. | |
468 // 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
|
469 // java_lang_Strings at resolved entries into Symbol*s |
0 | 470 // or vice versa. |
431
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
196
diff
changeset
|
471 // Caller is responsible for checking for pseudo-strings. |
0 | 472 char* string_at_noresolve(int which); |
473 | |
474 jint name_and_type_at(int which) { | |
475 assert(tag_at(which).is_name_and_type(), "Corrupted constant pool"); | |
476 return *int_at_addr(which); | |
477 } | |
478 | |
1602 | 479 int method_handle_ref_kind_at(int which) { |
480 assert(tag_at(which).is_method_handle(), "Corrupted constant pool"); | |
481 return extract_low_short_from_int(*int_at_addr(which)); // mask out unwanted ref_index bits | |
482 } | |
483 int method_handle_index_at(int which) { | |
484 assert(tag_at(which).is_method_handle(), "Corrupted constant pool"); | |
485 return extract_high_short_from_int(*int_at_addr(which)); // shift out unwanted ref_kind bits | |
486 } | |
487 int method_type_index_at(int which) { | |
488 assert(tag_at(which).is_method_type(), "Corrupted constant pool"); | |
489 return *int_at_addr(which); | |
490 } | |
491 // Derived queries: | |
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2011
diff
changeset
|
492 Symbol* method_handle_name_ref_at(int which) { |
1602 | 493 int member = method_handle_index_at(which); |
494 return impl_name_ref_at(member, true); | |
495 } | |
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2011
diff
changeset
|
496 Symbol* method_handle_signature_ref_at(int which) { |
1602 | 497 int member = method_handle_index_at(which); |
498 return impl_signature_ref_at(member, true); | |
499 } | |
500 int method_handle_klass_index_at(int which) { | |
501 int member = method_handle_index_at(which); | |
502 return impl_klass_ref_index_at(member, true); | |
503 } | |
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2011
diff
changeset
|
504 Symbol* method_type_signature_at(int which) { |
1602 | 505 int sym = method_type_index_at(which); |
506 return symbol_at(sym); | |
507 } | |
1913
3b2dea75431e
6984311: JSR 292 needs optional bootstrap method parameters
jrose
parents:
1910
diff
changeset
|
508 |
2011
dad31fc330cd
7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute
jrose
parents:
1972
diff
changeset
|
509 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
|
510 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
|
511 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
|
512 } |
2011
dad31fc330cd
7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute
jrose
parents:
1972
diff
changeset
|
513 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
|
514 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
|
515 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
|
516 } |
dad31fc330cd
7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute
jrose
parents:
1972
diff
changeset
|
517 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
|
518 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
|
519 return operand_offset_at(operands(), bootstrap_specifier_index); |
1913
3b2dea75431e
6984311: JSR 292 needs optional bootstrap method parameters
jrose
parents:
1910
diff
changeset
|
520 } |
2011
dad31fc330cd
7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute
jrose
parents:
1972
diff
changeset
|
521 // 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
|
522 // 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
|
523 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
|
524 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
|
525 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
|
526 // 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
|
527 // 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
|
528 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
|
529 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
|
530 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
|
531 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
|
532 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
|
533 // 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
|
534 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
|
535 return offset; |
1913
3b2dea75431e
6984311: JSR 292 needs optional bootstrap method parameters
jrose
parents:
1910
diff
changeset
|
536 } |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
537 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
|
538 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
|
539 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
|
540 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
|
541 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
|
542 } |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
543 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
|
544 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
|
545 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
|
546 return (second_part / 2); |
1913
3b2dea75431e
6984311: JSR 292 needs optional bootstrap method parameters
jrose
parents:
1910
diff
changeset
|
547 } |
3b2dea75431e
6984311: JSR 292 needs optional bootstrap method parameters
jrose
parents:
1910
diff
changeset
|
548 |
2011
dad31fc330cd
7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute
jrose
parents:
1972
diff
changeset
|
549 #ifdef ASSERT |
dad31fc330cd
7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute
jrose
parents:
1972
diff
changeset
|
550 // 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
|
551 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
|
552 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
|
553 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
|
554 return operands->length(); |
dad31fc330cd
7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute
jrose
parents:
1972
diff
changeset
|
555 else |
dad31fc330cd
7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute
jrose
parents:
1972
diff
changeset
|
556 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
|
557 } |
dad31fc330cd
7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute
jrose
parents:
1972
diff
changeset
|
558 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
|
559 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
|
560 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
|
561 } |
dad31fc330cd
7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute
jrose
parents:
1972
diff
changeset
|
562 #endif //ASSERT |
dad31fc330cd
7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute
jrose
parents:
1972
diff
changeset
|
563 |
dad31fc330cd
7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute
jrose
parents:
1972
diff
changeset
|
564 // 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
|
565 enum { |
3b2dea75431e
6984311: JSR 292 needs optional bootstrap method parameters
jrose
parents:
1910
diff
changeset
|
566 _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
|
567 _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
|
568 _indy_argv_offset = 2 // u2 argv[argc] |
1913
3b2dea75431e
6984311: JSR 292 needs optional bootstrap method parameters
jrose
parents:
1910
diff
changeset
|
569 }; |
1660
083fde3b838e
6964498: JSR 292 invokedynamic sites need local bootstrap methods
jrose
parents:
1602
diff
changeset
|
570 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
|
571 assert(tag_at(which).is_invoke_dynamic(), "Corrupted constant pool"); |
2011
dad31fc330cd
7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute
jrose
parents:
1972
diff
changeset
|
572 int op_base = invoke_dynamic_operand_base(which); |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
573 return operands()->at(op_base + _indy_bsm_offset); |
1913
3b2dea75431e
6984311: JSR 292 needs optional bootstrap method parameters
jrose
parents:
1910
diff
changeset
|
574 } |
3b2dea75431e
6984311: JSR 292 needs optional bootstrap method parameters
jrose
parents:
1910
diff
changeset
|
575 int invoke_dynamic_argument_count_at(int which) { |
3b2dea75431e
6984311: JSR 292 needs optional bootstrap method parameters
jrose
parents:
1910
diff
changeset
|
576 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
|
577 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
|
578 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
|
579 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
|
580 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
|
581 assert(end_offset == next_offset, "matched ending"); |
1913
3b2dea75431e
6984311: JSR 292 needs optional bootstrap method parameters
jrose
parents:
1910
diff
changeset
|
582 return argc; |
3b2dea75431e
6984311: JSR 292 needs optional bootstrap method parameters
jrose
parents:
1910
diff
changeset
|
583 } |
3b2dea75431e
6984311: JSR 292 needs optional bootstrap method parameters
jrose
parents:
1910
diff
changeset
|
584 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
|
585 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
|
586 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
|
587 assert((uint)j < (uint)argc, "oob"); |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
588 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
|
589 } |
1602 | 590 |
726
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
579
diff
changeset
|
591 // 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
|
592 // 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
|
593 // directly from the bytecode. |
1059
389049f3f393
6858164: invokedynamic code needs some cleanup (post-6655638)
jrose
parents:
726
diff
changeset
|
594 // 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
|
595 // actually rewritten constant pool cache indices. |
1059
389049f3f393
6858164: invokedynamic code needs some cleanup (post-6655638)
jrose
parents:
726
diff
changeset
|
596 // The routine remap_instruction_operand_from_cache manages the adjustment |
389049f3f393
6858164: invokedynamic code needs some cleanup (post-6655638)
jrose
parents:
726
diff
changeset
|
597 // of these values back to constant pool indices. |
726
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
579
diff
changeset
|
598 |
1059
389049f3f393
6858164: invokedynamic code needs some cleanup (post-6655638)
jrose
parents:
726
diff
changeset
|
599 // There are also "uncached" versions which do not adjust the operand index; see below. |
0 | 600 |
1910
d1896d1dda3e
6981788: GC map generator sometimes picks up the wrong kind of instruction operand
jrose
parents:
1660
diff
changeset
|
601 // 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
|
602 // 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
|
603 // 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
|
604 // 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
|
605 |
0 | 606 // 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
|
607 Klass* klass_ref_at(int which, TRAPS); |
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2011
diff
changeset
|
608 Symbol* klass_ref_at_noresolve(int which); |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2011
diff
changeset
|
609 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
|
610 Symbol* signature_ref_at(int which) { return impl_signature_ref_at(which, false); } |
0 | 611 |
726
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
579
diff
changeset
|
612 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
|
613 int name_and_type_ref_index_at(int which) { return impl_name_and_type_ref_index_at(which, false); } |
0 | 614 |
615 // Lookup for entries consisting of (name_index, signature_index) | |
726
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
579
diff
changeset
|
616 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
|
617 int signature_ref_index_at(int which_nt); // == high-order jshort of name_and_type_at(which_nt) |
0 | 618 |
619 BasicType basic_type_for_signature_at(int which); | |
620 | |
621 // Resolve string constants (to prevent allocation during compilation) | |
622 void resolve_string_constants(TRAPS) { | |
623 constantPoolHandle h_this(THREAD, this); | |
624 resolve_string_constants_impl(h_this, CHECK); | |
625 } | |
626 | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
627 // CDS support |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
628 void remove_unshareable_info(); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
629 void restore_unshareable_info(TRAPS); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
630 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
|
631 // 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
|
632 // 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
|
633 // 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
|
634 // 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
|
635 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
|
636 |
1913
3b2dea75431e
6984311: JSR 292 needs optional bootstrap method parameters
jrose
parents:
1910
diff
changeset
|
637 private: |
3b2dea75431e
6984311: JSR 292 needs optional bootstrap method parameters
jrose
parents:
1910
diff
changeset
|
638 enum { _no_index_sentinel = -1, _possible_index_sentinel = -2 }; |
3b2dea75431e
6984311: JSR 292 needs optional bootstrap method parameters
jrose
parents:
1910
diff
changeset
|
639 public: |
3b2dea75431e
6984311: JSR 292 needs optional bootstrap method parameters
jrose
parents:
1910
diff
changeset
|
640 |
1602 | 641 // Resolve late bound constants. |
642 oop resolve_constant_at(int index, TRAPS) { | |
643 constantPoolHandle h_this(THREAD, this); | |
1913
3b2dea75431e
6984311: JSR 292 needs optional bootstrap method parameters
jrose
parents:
1910
diff
changeset
|
644 return resolve_constant_at_impl(h_this, index, _no_index_sentinel, THREAD); |
1602 | 645 } |
646 | |
647 oop resolve_cached_constant_at(int cache_index, TRAPS) { | |
648 constantPoolHandle h_this(THREAD, this); | |
1913
3b2dea75431e
6984311: JSR 292 needs optional bootstrap method parameters
jrose
parents:
1910
diff
changeset
|
649 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
|
650 } |
3b2dea75431e
6984311: JSR 292 needs optional bootstrap method parameters
jrose
parents:
1910
diff
changeset
|
651 |
3b2dea75431e
6984311: JSR 292 needs optional bootstrap method parameters
jrose
parents:
1910
diff
changeset
|
652 oop resolve_possibly_cached_constant_at(int pool_index, TRAPS) { |
3b2dea75431e
6984311: JSR 292 needs optional bootstrap method parameters
jrose
parents:
1910
diff
changeset
|
653 constantPoolHandle h_this(THREAD, this); |
3b2dea75431e
6984311: JSR 292 needs optional bootstrap method parameters
jrose
parents:
1910
diff
changeset
|
654 return resolve_constant_at_impl(h_this, pool_index, _possible_index_sentinel, THREAD); |
1602 | 655 } |
656 | |
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6197
diff
changeset
|
657 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
|
658 constantPoolHandle h_this(THREAD, this); |
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6197
diff
changeset
|
659 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
|
660 } |
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6197
diff
changeset
|
661 |
0 | 662 // Klass name matches name at offset |
663 bool klass_name_at_matches(instanceKlassHandle k, int which); | |
664 | |
665 // Sizing | |
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
666 int length() const { return _length; } |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
667 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
|
668 |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
669 // 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
|
670 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
|
671 return 0 <= index && index < length(); |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
672 } |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
673 |
7956 | 674 // Sizing (in words) |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
675 static int header_size() { return sizeof(ConstantPool)/HeapWordSize; } |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
676 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
|
677 int size() const { return size(length()); } |
7956 | 678 #if INCLUDE_SERVICES |
679 void collect_statistics(KlassSizeStats *sz) const; | |
680 #endif | |
0 | 681 |
682 friend class ClassFileParser; | |
683 friend class SystemDictionary; | |
684 | |
685 // 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
|
686 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
|
687 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
|
688 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
|
689 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
|
690 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
|
691 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
|
692 static Klass* klass_ref_at_if_loaded (constantPoolHandle this_oop, int which); |
0 | 693 // 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
|
694 static Klass* klass_ref_at_if_loaded_check(constantPoolHandle this_oop, int which, TRAPS); |
0 | 695 |
696 // 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
|
697 // future by other Java code. These take constant pool indices rather than |
0 | 698 // 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
|
699 Symbol* uncached_klass_ref_at_noresolve(int which); |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2011
diff
changeset
|
700 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
|
701 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
|
702 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
|
703 int uncached_name_and_type_ref_index_at(int which) { return impl_name_and_type_ref_index_at(which, true); } |
0 | 704 |
705 // Sharing | |
706 int pre_resolve_shared_klasses(TRAPS); | |
707 | |
708 // Debugging | |
709 const char* printable_name_at(int which) PRODUCT_RETURN0; | |
710 | |
1565 | 711 #ifdef ASSERT |
712 enum { CPCACHE_INDEX_TAG = 0x10000 }; // helps keep CP cache indices distinct from CP indices | |
1602 | 713 #else |
714 enum { CPCACHE_INDEX_TAG = 0 }; // in product mode, this zero value is a no-op | |
1565 | 715 #endif //ASSERT |
716 | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
717 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
|
718 if (invokedynamic_ok && is_invokedynamic_index(raw_index)) |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
719 return decode_invokedynamic_index(raw_index); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
720 else |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
721 return raw_index - CPCACHE_INDEX_TAG; |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
722 } |
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6197
diff
changeset
|
723 |
0 | 724 private: |
725 | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
726 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
|
727 Array<u2>* reference_map() const { return _reference_map; } |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
728 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
|
729 |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
730 // 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
|
731 void patch_resolved_references(GrowableArray<Handle>* cp_patches); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
732 |
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2011
diff
changeset
|
733 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
|
734 Symbol* impl_signature_ref_at(int which, bool uncached); |
726
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
579
diff
changeset
|
735 int impl_klass_ref_index_at(int which, bool uncached); |
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
579
diff
changeset
|
736 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
|
737 |
1565 | 738 int remap_instruction_operand_from_cache(int operand); // operand must be biased by CPCACHE_INDEX_TAG |
0 | 739 |
740 // Used while constructing constant pool (only by ClassFileParser) | |
741 jint klass_index_at(int which) { | |
742 assert(tag_at(which).is_klass_index(), "Corrupted constant pool"); | |
743 return *int_at_addr(which); | |
744 } | |
745 | |
746 jint string_index_at(int which) { | |
747 assert(tag_at(which).is_string_index(), "Corrupted constant pool"); | |
748 return *int_at_addr(which); | |
749 } | |
750 | |
751 // Performs the LinkResolver checks | |
752 static void verify_constant_pool_resolve(constantPoolHandle this_oop, KlassHandle klass, TRAPS); | |
753 | |
754 // Implementation of methods that needs an exposed 'this' pointer, in order to | |
755 // handle GC while executing the method | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
756 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
|
757 static oop string_at_impl(constantPoolHandle this_oop, int which, int obj_index, TRAPS); |
0 | 758 |
759 // Resolve string constants (to prevent allocation during compilation) | |
760 static void resolve_string_constants_impl(constantPoolHandle this_oop, TRAPS); | |
761 | |
1602 | 762 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
|
763 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
|
764 static oop resolve_bootstrap_specifier_at_impl(constantPoolHandle this_oop, int index, TRAPS); |
1602 | 765 |
0 | 766 public: |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
767 // Merging ConstantPool* support: |
0 | 768 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
|
769 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
|
770 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
|
771 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
|
772 } |
dad31fc330cd
7001379: bootstrap method data needs to be moved from constant pool to a classfile attribute
jrose
parents:
1972
diff
changeset
|
773 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
|
774 static void copy_entry_to(constantPoolHandle from_cp, int from_i, constantPoolHandle to_cp, int to_i, TRAPS); |
7952
edd76a5856f7
8005128: JSR 292: the mlvm redefineClassInBootstrap test crashes in ConstantPool::compare_entry_to
sspitsyn
parents:
7949
diff
changeset
|
775 static void copy_operands(constantPoolHandle from_cp, constantPoolHandle to_cp, TRAPS); |
0 | 776 int find_matching_entry(int pattern_i, constantPoolHandle search_cp, TRAPS); |
7624
b14da2e6f2dc
7174978: NPG: Fix bactrace builder for class redefinition
coleenp
parents:
6940
diff
changeset
|
777 int version() const { return _saved._version; } |
b14da2e6f2dc
7174978: NPG: Fix bactrace builder for class redefinition
coleenp
parents:
6940
diff
changeset
|
778 void set_version(int version) { _saved._version = version; } |
b14da2e6f2dc
7174978: NPG: Fix bactrace builder for class redefinition
coleenp
parents:
6940
diff
changeset
|
779 void increment_and_save_version(int version) { |
7625 | 780 _saved._version = version >= 0 ? (version + 1) : version; // keep overflow |
7624
b14da2e6f2dc
7174978: NPG: Fix bactrace builder for class redefinition
coleenp
parents:
6940
diff
changeset
|
781 } |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
782 |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
783 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
|
784 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
|
785 void set_lock(Monitor* lock) { _lock = lock; } |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
786 Monitor* lock() { return _lock; } |
0 | 787 |
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2011
diff
changeset
|
788 // 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
|
789 // when the holder class is unloaded |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2011
diff
changeset
|
790 void unreference_symbols(); |
0 | 791 |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
792 // Deallocate constant pool for RedefineClasses |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
793 void deallocate_contents(ClassLoaderData* loader_data); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
794 void release_C_heap_structures(); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
795 |
0 | 796 // JVMTI accesss - GetConstantPool, RetransformClasses, ... |
797 friend class JvmtiConstantPoolReconstituter; | |
798 | |
799 private: | |
800 jint cpool_entry_size(jint idx); | |
801 jint hash_entries_to(SymbolHashMap *symmap, SymbolHashMap *classmap); | |
802 | |
803 // Copy cpool bytes into byte array. | |
804 // Returns: | |
805 // int > 0, count of the raw cpool bytes that have been copied | |
806 // 0, OutOfMemory error | |
807 // -1, Internal error | |
808 int copy_cpool_bytes(int cpool_size, | |
809 SymbolHashMap* tbl, | |
810 unsigned char *bytes); | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
811 |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
812 public: |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
813 // Verify |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
814 void verify_on(outputStream* st); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
815 |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
816 // Printing |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
817 void print_on(outputStream* st) const; |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
818 void print_value_on(outputStream* st) const; |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
819 void print_entry_on(int index, outputStream* st); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
820 |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
821 const char* internal_name() const { return "{constant pool}"; } |
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 #ifndef PRODUCT |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
824 // Compile the world support |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
825 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
|
826 #endif |
0 | 827 }; |
828 | |
6197 | 829 class SymbolHashMapEntry : public CHeapObj<mtSymbol> { |
0 | 830 private: |
831 unsigned int _hash; // 32-bit hash for item | |
832 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
|
833 Symbol* _symbol; // 1-st part of the mapping: symbol => value |
0 | 834 u2 _value; // 2-nd part of the mapping: symbol => value |
835 | |
836 public: | |
837 unsigned int hash() const { return _hash; } | |
838 void set_hash(unsigned int hash) { _hash = hash; } | |
839 | |
840 SymbolHashMapEntry* next() const { return _next; } | |
841 void set_next(SymbolHashMapEntry* next) { _next = next; } | |
842 | |
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2011
diff
changeset
|
843 Symbol* symbol() const { return _symbol; } |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2011
diff
changeset
|
844 void set_symbol(Symbol* sym) { _symbol = sym; } |
0 | 845 |
846 u2 value() const { return _value; } | |
847 void set_value(u2 value) { _value = value; } | |
848 | |
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2011
diff
changeset
|
849 SymbolHashMapEntry(unsigned int hash, Symbol* symbol, u2 value) |
0 | 850 : _hash(hash), _symbol(symbol), _value(value), _next(NULL) {} |
851 | |
852 }; // End SymbolHashMapEntry class | |
853 | |
854 | |
6197 | 855 class SymbolHashMapBucket : public CHeapObj<mtSymbol> { |
0 | 856 |
857 private: | |
858 SymbolHashMapEntry* _entry; | |
859 | |
860 public: | |
861 SymbolHashMapEntry* entry() const { return _entry; } | |
862 void set_entry(SymbolHashMapEntry* entry) { _entry = entry; } | |
863 void clear() { _entry = NULL; } | |
864 | |
865 }; // End SymbolHashMapBucket class | |
866 | |
867 | |
6197 | 868 class SymbolHashMap: public CHeapObj<mtSymbol> { |
0 | 869 |
870 private: | |
871 // Default number of entries in the table | |
872 enum SymbolHashMap_Constants { | |
873 _Def_HashMap_Size = 256 | |
874 }; | |
875 | |
876 int _table_size; | |
877 SymbolHashMapBucket* _buckets; | |
878 | |
879 void initialize_table(int table_size) { | |
880 _table_size = table_size; | |
6197 | 881 _buckets = NEW_C_HEAP_ARRAY(SymbolHashMapBucket, table_size, mtSymbol); |
0 | 882 for (int index = 0; index < table_size; index++) { |
883 _buckets[index].clear(); | |
884 } | |
885 } | |
886 | |
887 public: | |
888 | |
889 int table_size() const { return _table_size; } | |
890 | |
891 SymbolHashMap() { initialize_table(_Def_HashMap_Size); } | |
892 SymbolHashMap(int table_size) { initialize_table(table_size); } | |
893 | |
894 // hash P(31) from Kernighan & Ritchie | |
895 static unsigned int compute_hash(const char* str, int len) { | |
896 unsigned int hash = 0; | |
897 while (len-- > 0) { | |
898 hash = 31*hash + (unsigned) *str; | |
899 str++; | |
900 } | |
901 return hash; | |
902 } | |
903 | |
904 SymbolHashMapEntry* bucket(int i) { | |
905 return _buckets[i].entry(); | |
906 } | |
907 | |
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2011
diff
changeset
|
908 void add_entry(Symbol* sym, u2 value); |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2011
diff
changeset
|
909 SymbolHashMapEntry* find_entry(Symbol* sym); |
0 | 910 |
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2011
diff
changeset
|
911 u2 symbol_to_value(Symbol* sym) { |
0 | 912 SymbolHashMapEntry *entry = find_entry(sym); |
913 return (entry == NULL) ? 0 : entry->value(); | |
914 } | |
915 | |
916 ~SymbolHashMap() { | |
917 SymbolHashMapEntry* next; | |
918 for (int i = 0; i < _table_size; i++) { | |
919 for (SymbolHashMapEntry* cur = bucket(i); cur != NULL; cur = next) { | |
920 next = cur->next(); | |
921 delete(cur); | |
922 } | |
923 } | |
924 delete _buckets; | |
925 } | |
926 }; // End SymbolHashMap class | |
1972 | 927 |
928 #endif // SHARE_VM_OOPS_CONSTANTPOOLOOP_HPP |