1 /*
2 * Copyright (c) 1997, 2010, 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 "incls/_precompiled.incl"
26 #include "incls/_bytecode.cpp.incl"
27
28 // Implementation of Bytecode
29
30 bool Bytecode::check_must_rewrite(Bytecodes::Code code) const {
31 assert(Bytecodes::can_rewrite(code), "post-check only");
32
33 // Some codes are conditionally rewriting. Look closely at them.
34 switch (code) {
35 case Bytecodes::_aload_0:
36 // Even if RewriteFrequentPairs is turned on,
37 // the _aload_0 code might delay its rewrite until
38 // a following _getfield rewrites itself.
39 return false;
40
41 case Bytecodes::_lookupswitch:
42 return false; // the rewrite is not done by the interpreter
43
44 case Bytecodes::_new:
45 // (Could actually look at the class here, but the profit would be small.)
46 return false; // the rewrite is not always done
47 }
48
49 // No other special cases.
50 return true;
51 }
52
53
54 #ifdef ASSERT
55
56 void Bytecode::assert_same_format_as(Bytecodes::Code testbc, bool is_wide) const {
57 Bytecodes::Code thisbc = Bytecodes::cast(byte_at(0));
58 if (thisbc == Bytecodes::_breakpoint) return; // let the assertion fail silently
59 if (is_wide) {
60 assert(thisbc == Bytecodes::_wide, "expected a wide instruction");
61 thisbc = Bytecodes::cast(byte_at(1));
62 if (thisbc == Bytecodes::_breakpoint) return;
63 }
64 int thisflags = Bytecodes::flags(testbc, is_wide) & Bytecodes::_all_fmt_bits;
65 int testflags = Bytecodes::flags(thisbc, is_wide) & Bytecodes::_all_fmt_bits;
66 if (thisflags != testflags)
67 tty->print_cr("assert_same_format_as(%d) failed on bc=%d%s; %d != %d",
68 (int)testbc, (int)thisbc, (is_wide?"/wide":""), testflags, thisflags);
69 assert(thisflags == testflags, "expected format");
70 }
71
72 void Bytecode::assert_index_size(int size, Bytecodes::Code bc, bool is_wide) {
73 int have_fmt = (Bytecodes::flags(bc, is_wide)
74 & (Bytecodes::_fmt_has_u2 | Bytecodes::_fmt_has_u4 |
75 Bytecodes::_fmt_not_simple |
76 // Not an offset field:
77 Bytecodes::_fmt_has_o));
78 int need_fmt = -1;
79 switch (size) {
80 case 1: need_fmt = 0; break;
81 case 2: need_fmt = Bytecodes::_fmt_has_u2; break;
82 case 4: need_fmt = Bytecodes::_fmt_has_u4; break;
83 }
84 if (is_wide) need_fmt |= Bytecodes::_fmt_not_simple;
85 if (have_fmt != need_fmt) {
86 tty->print_cr("assert_index_size %d: bc=%d%s %d != %d", size, bc, (is_wide?"/wide":""), have_fmt, need_fmt);
87 assert(have_fmt == need_fmt, "assert_index_size");
88 }
89 }
90
91 void Bytecode::assert_offset_size(int size, Bytecodes::Code bc, bool is_wide) {
92 int have_fmt = Bytecodes::flags(bc, is_wide) & Bytecodes::_all_fmt_bits;
93 int need_fmt = -1;
94 switch (size) {
95 case 2: need_fmt = Bytecodes::_fmt_bo2; break;
96 case 4: need_fmt = Bytecodes::_fmt_bo4; break;
97 }
98 if (is_wide) need_fmt |= Bytecodes::_fmt_not_simple;
99 if (have_fmt != need_fmt) {
100 tty->print_cr("assert_offset_size %d: bc=%d%s %d != %d", size, bc, (is_wide?"/wide":""), have_fmt, need_fmt);
101 assert(have_fmt == need_fmt, "assert_offset_size");
102 }
103 }
104
105 void Bytecode::assert_constant_size(int size, int where, Bytecodes::Code bc, bool is_wide) {
106 int have_fmt = Bytecodes::flags(bc, is_wide) & (Bytecodes::_all_fmt_bits
107 // Ignore any 'i' field (for iinc):
108 & ~Bytecodes::_fmt_has_i);
109 int need_fmt = -1;
110 switch (size) {
111 case 1: need_fmt = Bytecodes::_fmt_bc; break;
112 case 2: need_fmt = Bytecodes::_fmt_bc | Bytecodes::_fmt_has_u2; break;
113 }
114 if (is_wide) need_fmt |= Bytecodes::_fmt_not_simple;
115 int length = is_wide ? Bytecodes::wide_length_for(bc) : Bytecodes::length_for(bc);
116 if (have_fmt != need_fmt || where + size != length) {
117 tty->print_cr("assert_constant_size %d @%d: bc=%d%s %d != %d", size, where, bc, (is_wide?"/wide":""), have_fmt, need_fmt);
118 }
119 assert(have_fmt == need_fmt, "assert_constant_size");
120 assert(where + size == length, "assert_constant_size oob");
121 }
122
123 void Bytecode::assert_native_index(Bytecodes::Code bc, bool is_wide) {
124 assert((Bytecodes::flags(bc, is_wide) & Bytecodes::_fmt_has_nbo) != 0, "native index");
125 }
126
127 #endif //ASSERT
128
129 // Implementation of Bytecode_tableupswitch
130
131 int Bytecode_tableswitch::dest_offset_at(int i) const {
132 return get_Java_u4_at(aligned_offset(1 + (3 + i)*jintSize));
133 }
134
135
136 // Implementation of Bytecode_invoke
137
138 void Bytecode_invoke::verify() const {
139 assert(is_valid(), "check invoke");
140 assert(method()->constants()->cache() != NULL, "do not call this from verifier or rewriter");
141 }
142
143
144 symbolOop Bytecode_member_ref::signature() const {
145 constantPoolOop constants = method()->constants();
146 return constants->signature_ref_at(index());
147 }
148
149
150 symbolOop Bytecode_member_ref::name() const {
151 constantPoolOop constants = method()->constants();
152 return constants->name_ref_at(index());
153 }
154
155
156 BasicType Bytecode_member_ref::result_type(Thread *thread) const {
157 symbolHandle sh(thread, signature());
158 ResultTypeFinder rts(sh);
159 rts.iterate();
160 return rts.type();
161 }
162
163
164 methodHandle Bytecode_invoke::static_target(TRAPS) {
165 methodHandle m;
166 KlassHandle resolved_klass;
167 constantPoolHandle constants(THREAD, _method->constants());
168
169 if (java_code() == Bytecodes::_invokedynamic) {
170 LinkResolver::resolve_dynamic_method(m, resolved_klass, constants, index(), CHECK_(methodHandle()));
171 } else if (java_code() != Bytecodes::_invokeinterface) {
172 LinkResolver::resolve_method(m, resolved_klass, constants, index(), CHECK_(methodHandle()));
173 } else {
174 LinkResolver::resolve_interface_method(m, resolved_klass, constants, index(), CHECK_(methodHandle()));
175 }
176 return m;
177 }
178
179
180 int Bytecode_member_ref::index() const {
181 // Note: Rewriter::rewrite changes the Java_u2 of an invokedynamic to a native_u4,
182 // at the same time it allocates per-call-site CP cache entries.
183 Bytecodes::Code rawc = code();
184 Bytecode* invoke = bytecode();
185 if (invoke->has_index_u4(rawc))
186 return invoke->get_index_u4(rawc);
187 else
188 return invoke->get_index_u2_cpcache(rawc);
189 }
190
191 int Bytecode_member_ref::pool_index() const {
192 int index = this->index();
193 DEBUG_ONLY({
194 if (!bytecode()->has_index_u4(code()))
195 index -= constantPoolOopDesc::CPCACHE_INDEX_TAG;
196 });
197 return _method->constants()->cache()->entry_at(index)->constant_pool_index();
198 }
199
200 // Implementation of Bytecode_field
201
202 void Bytecode_field::verify() const {
203 assert(is_valid(), "check field");
204 }
205
206
207 // Implementation of Bytecode_loadconstant
208
209 int Bytecode_loadconstant::raw_index() const {
210 Bytecode* bcp = bytecode();
211 Bytecodes::Code rawc = bcp->code();
212 assert(rawc != Bytecodes::_wide, "verifier prevents this");
213 if (Bytecodes::java_code(rawc) == Bytecodes::_ldc)
214 return bcp->get_index_u1(rawc);
215 else
216 return bcp->get_index_u2(rawc, false);
217 }
218
219 int Bytecode_loadconstant::pool_index() const {
220 int index = raw_index();
221 if (has_cache_index()) {
222 return _method->constants()->cache()->entry_at(index)->constant_pool_index();
223 }
224 return index;
225 }
226
227 BasicType Bytecode_loadconstant::result_type() const {
228 int index = pool_index();
229 constantTag tag = _method->constants()->tag_at(index);
230 return tag.basic_type();
231 }
232
233 oop Bytecode_loadconstant::resolve_constant(TRAPS) const {
234 assert(_method.not_null(), "must supply method to resolve constant");
235 int index = raw_index();
236 constantPoolOop constants = _method->constants();
237 if (has_cache_index()) {
238 return constants->resolve_cached_constant_at(index, THREAD);
239 } else {
240 return constants->resolve_constant_at(index, THREAD);
241 }
242 }
243
244 //------------------------------------------------------------------------------
245 // Non-product code
246
247 #ifndef PRODUCT
248
249 void Bytecode_lookupswitch::verify() const {
250 switch (Bytecodes::java_code(code())) {
251 case Bytecodes::_lookupswitch:
252 { int i = number_of_pairs() - 1;
253 while (i-- > 0) {
254 assert(pair_at(i)->match() < pair_at(i+1)->match(), "unsorted table entries");
255 }
256 }
257 break;
258 default:
259 fatal("not a lookupswitch bytecode");
260 }
261 }
262
263 void Bytecode_tableswitch::verify() const {
264 switch (Bytecodes::java_code(code())) {
265 case Bytecodes::_tableswitch:
266 { int lo = low_key();
267 int hi = high_key();
268 assert (hi >= lo, "incorrect hi/lo values in tableswitch");
269 int i = hi - lo - 1 ;
270 while (i-- > 0) {
271 // no special check needed
272 }
273 }
274 break;
275 default:
276 fatal("not a tableswitch bytecode");
277 }
278 }
279
280 #endif