Mercurial > hg > truffle
annotate src/share/vm/classfile/bytecodeAssembler.cpp @ 12837:82af7d7a0128
8003420: NPG: make new GC root for pd_set
Summary: Move protection domain oops from system dictionary entries into a seperate set; the system dictionary references entries in that set now. This allows fast iteration during non-classunloading garbage collection. Implementation based on initial prototype from Ioi Lam (iklam).
Reviewed-by: coleenp, iklam
author | tschatzl |
---|---|
date | Wed, 09 Oct 2013 10:57:01 +0200 |
parents | d9b08d62b95e |
children | de6a9e811145 |
rev | line source |
---|---|
6934 | 1 /* |
2 * Copyright (c) 2012, Oracle and/or its affiliates. All rights reserved. | |
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 * | |
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA | |
20 * or visit www.oracle.com if you need additional information or have any | |
21 * questions. | |
22 * | |
23 */ | |
24 | |
25 #include "precompiled.hpp" | |
26 | |
27 #include "classfile/bytecodeAssembler.hpp" | |
28 #include "interpreter/bytecodes.hpp" | |
29 #include "memory/oopFactory.hpp" | |
30 #include "oops/constantPool.hpp" | |
31 | |
32 #ifdef TARGET_ARCH_x86 | |
33 # include "bytes_x86.hpp" | |
34 #endif | |
35 #ifdef TARGET_ARCH_sparc | |
36 # include "bytes_sparc.hpp" | |
37 #endif | |
38 #ifdef TARGET_ARCH_zero | |
39 # include "bytes_zero.hpp" | |
40 #endif | |
41 #ifdef TARGET_ARCH_arm | |
42 # include "bytes_arm.hpp" | |
43 #endif | |
44 #ifdef TARGET_ARCH_ppc | |
45 # include "bytes_ppc.hpp" | |
46 #endif | |
47 | |
48 u2 BytecodeConstantPool::find_or_add(BytecodeCPEntry const& bcpe) { | |
49 u2 index; | |
50 u2* probe = _indices.get(bcpe); | |
51 if (probe == NULL) { | |
52 index = _entries.length(); | |
53 _entries.append(bcpe); | |
54 _indices.put(bcpe, index); | |
55 } else { | |
56 index = *probe; | |
57 } | |
58 return index + _orig->length(); | |
59 } | |
60 | |
61 ConstantPool* BytecodeConstantPool::create_constant_pool(TRAPS) const { | |
62 if (_entries.length() == 0) { | |
63 return _orig; | |
64 } | |
65 | |
66 ConstantPool* cp = ConstantPool::allocate( | |
67 _orig->pool_holder()->class_loader_data(), | |
68 _orig->length() + _entries.length(), CHECK_NULL); | |
69 | |
70 cp->set_pool_holder(_orig->pool_holder()); | |
71 _orig->copy_cp_to(1, _orig->length() - 1, cp, 1, CHECK_NULL); | |
72 | |
73 for (int i = 0; i < _entries.length(); ++i) { | |
74 BytecodeCPEntry entry = _entries.at(i); | |
75 int idx = i + _orig->length(); | |
76 switch (entry._tag) { | |
77 case BytecodeCPEntry::UTF8: | |
10223
d9b08d62b95e
8010783: assert(s->refcount() != 0) failed: for create_overpasses
acorn
parents:
6934
diff
changeset
|
78 entry._u.utf8->increment_refcount(); |
6934 | 79 cp->symbol_at_put(idx, entry._u.utf8); |
80 break; | |
81 case BytecodeCPEntry::KLASS: | |
82 cp->unresolved_klass_at_put( | |
83 idx, cp->symbol_at(entry._u.klass)); | |
84 break; | |
85 case BytecodeCPEntry::STRING: | |
86 cp->unresolved_string_at_put( | |
87 idx, cp->symbol_at(entry._u.string)); | |
88 break; | |
89 case BytecodeCPEntry::NAME_AND_TYPE: | |
90 cp->name_and_type_at_put(idx, | |
91 entry._u.name_and_type.name_index, | |
92 entry._u.name_and_type.type_index); | |
93 break; | |
94 case BytecodeCPEntry::METHODREF: | |
95 cp->method_at_put(idx, | |
96 entry._u.methodref.class_index, | |
97 entry._u.methodref.name_and_type_index); | |
98 break; | |
99 default: | |
100 ShouldNotReachHere(); | |
101 } | |
102 } | |
103 return cp; | |
104 } | |
105 | |
106 void BytecodeAssembler::append(u1 imm_u1) { | |
107 _code->append(imm_u1); | |
108 } | |
109 | |
110 void BytecodeAssembler::append(u2 imm_u2) { | |
111 _code->append(0); | |
112 _code->append(0); | |
113 Bytes::put_Java_u2(_code->adr_at(_code->length() - 2), imm_u2); | |
114 } | |
115 | |
116 void BytecodeAssembler::append(u4 imm_u4) { | |
117 _code->append(0); | |
118 _code->append(0); | |
119 _code->append(0); | |
120 _code->append(0); | |
121 Bytes::put_Java_u4(_code->adr_at(_code->length() - 4), imm_u4); | |
122 } | |
123 | |
124 void BytecodeAssembler::xload(u4 index, u1 onebyteop, u1 twobyteop) { | |
125 if (index < 4) { | |
126 _code->append(onebyteop + index); | |
127 } else { | |
128 _code->append(twobyteop); | |
129 _code->append((u2)index); | |
130 } | |
131 } | |
132 | |
133 void BytecodeAssembler::dup() { | |
134 _code->append(Bytecodes::_dup); | |
135 } | |
136 | |
137 void BytecodeAssembler::_new(Symbol* sym) { | |
138 u2 cpool_index = _cp->klass(sym); | |
139 _code->append(Bytecodes::_new); | |
140 append(cpool_index); | |
141 } | |
142 | |
143 void BytecodeAssembler::load_string(Symbol* sym) { | |
144 u2 cpool_index = _cp->string(sym); | |
145 if (cpool_index < 0x100) { | |
146 ldc(cpool_index); | |
147 } else { | |
148 ldc_w(cpool_index); | |
149 } | |
150 } | |
151 | |
152 void BytecodeAssembler::ldc(u1 index) { | |
153 _code->append(Bytecodes::_ldc); | |
154 append(index); | |
155 } | |
156 | |
157 void BytecodeAssembler::ldc_w(u2 index) { | |
158 _code->append(Bytecodes::_ldc_w); | |
159 append(index); | |
160 } | |
161 | |
162 void BytecodeAssembler::athrow() { | |
163 _code->append(Bytecodes::_athrow); | |
164 } | |
165 | |
166 void BytecodeAssembler::iload(u4 index) { | |
167 xload(index, Bytecodes::_iload_0, Bytecodes::_iload); | |
168 } | |
169 | |
170 void BytecodeAssembler::lload(u4 index) { | |
171 xload(index, Bytecodes::_lload_0, Bytecodes::_lload); | |
172 } | |
173 | |
174 void BytecodeAssembler::fload(u4 index) { | |
175 xload(index, Bytecodes::_fload_0, Bytecodes::_fload); | |
176 } | |
177 | |
178 void BytecodeAssembler::dload(u4 index) { | |
179 xload(index, Bytecodes::_dload_0, Bytecodes::_dload); | |
180 } | |
181 | |
182 void BytecodeAssembler::aload(u4 index) { | |
183 xload(index, Bytecodes::_aload_0, Bytecodes::_aload); | |
184 } | |
185 | |
186 void BytecodeAssembler::load(BasicType bt, u4 index) { | |
187 switch (bt) { | |
188 case T_BOOLEAN: | |
189 case T_CHAR: | |
190 case T_BYTE: | |
191 case T_SHORT: | |
192 case T_INT: iload(index); break; | |
193 case T_FLOAT: fload(index); break; | |
194 case T_DOUBLE: dload(index); break; | |
195 case T_LONG: lload(index); break; | |
196 case T_OBJECT: | |
197 case T_ARRAY: aload(index); break; | |
198 default: | |
199 ShouldNotReachHere(); | |
200 } | |
201 } | |
202 | |
203 void BytecodeAssembler::checkcast(Symbol* sym) { | |
204 u2 cpool_index = _cp->klass(sym); | |
205 _code->append(Bytecodes::_checkcast); | |
206 append(cpool_index); | |
207 } | |
208 | |
209 void BytecodeAssembler::invokespecial(Method* method) { | |
210 invokespecial(method->klass_name(), method->name(), method->signature()); | |
211 } | |
212 | |
213 void BytecodeAssembler::invokespecial(Symbol* klss, Symbol* name, Symbol* sig) { | |
214 u2 methodref_index = _cp->methodref(klss, name, sig); | |
215 _code->append(Bytecodes::_invokespecial); | |
216 append(methodref_index); | |
217 } | |
218 | |
219 void BytecodeAssembler::invokevirtual(Method* method) { | |
220 invokevirtual(method->klass_name(), method->name(), method->signature()); | |
221 } | |
222 | |
223 void BytecodeAssembler::invokevirtual(Symbol* klss, Symbol* name, Symbol* sig) { | |
224 u2 methodref_index = _cp->methodref(klss, name, sig); | |
225 _code->append(Bytecodes::_invokevirtual); | |
226 append(methodref_index); | |
227 } | |
228 | |
229 void BytecodeAssembler::ireturn() { | |
230 _code->append(Bytecodes::_ireturn); | |
231 } | |
232 | |
233 void BytecodeAssembler::lreturn() { | |
234 _code->append(Bytecodes::_lreturn); | |
235 } | |
236 | |
237 void BytecodeAssembler::freturn() { | |
238 _code->append(Bytecodes::_freturn); | |
239 } | |
240 | |
241 void BytecodeAssembler::dreturn() { | |
242 _code->append(Bytecodes::_dreturn); | |
243 } | |
244 | |
245 void BytecodeAssembler::areturn() { | |
246 _code->append(Bytecodes::_areturn); | |
247 } | |
248 | |
249 void BytecodeAssembler::_return() { | |
250 _code->append(Bytecodes::_return); | |
251 } | |
252 | |
253 void BytecodeAssembler::_return(BasicType bt) { | |
254 switch (bt) { | |
255 case T_BOOLEAN: | |
256 case T_CHAR: | |
257 case T_BYTE: | |
258 case T_SHORT: | |
259 case T_INT: ireturn(); break; | |
260 case T_FLOAT: freturn(); break; | |
261 case T_DOUBLE: dreturn(); break; | |
262 case T_LONG: lreturn(); break; | |
263 case T_OBJECT: | |
264 case T_ARRAY: areturn(); break; | |
265 case T_VOID: _return(); break; | |
266 default: | |
267 ShouldNotReachHere(); | |
268 } | |
269 } |