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:
|
|
78 cp->symbol_at_put(idx, entry._u.utf8);
|
|
79 entry._u.utf8->increment_refcount();
|
|
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 }
|