|
1 /* |
|
2 * Copyright (c) 1999, 2016, 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 #ifndef SHARE_VM_CI_CISTREAMS_HPP |
|
26 #define SHARE_VM_CI_CISTREAMS_HPP |
|
27 |
|
28 #include "ci/ciClassList.hpp" |
|
29 #include "ci/ciExceptionHandler.hpp" |
|
30 #include "ci/ciInstanceKlass.hpp" |
|
31 #include "ci/ciMethod.hpp" |
|
32 #include "interpreter/bytecode.hpp" |
|
33 |
|
34 // ciBytecodeStream |
|
35 // |
|
36 // The class is used to iterate over the bytecodes of a method. |
|
37 // It hides the details of constant pool structure/access by |
|
38 // providing accessors for constant pool items. It returns only pure |
|
39 // Java bytecodes; VM-internal _fast bytecodes are translated back to |
|
40 // their original form during iteration. |
|
41 class ciBytecodeStream : StackObj { |
|
42 private: |
|
43 // Handling for the weird bytecodes |
|
44 Bytecodes::Code next_wide_or_table(Bytecodes::Code); // Handle _wide & complicated inline table |
|
45 |
|
46 static Bytecodes::Code check_java(Bytecodes::Code c) { |
|
47 assert(Bytecodes::is_java_code(c), "should not return _fast bytecodes"); |
|
48 return c; |
|
49 } |
|
50 |
|
51 static Bytecodes::Code check_defined(Bytecodes::Code c) { |
|
52 assert(Bytecodes::is_defined(c), ""); |
|
53 return c; |
|
54 } |
|
55 |
|
56 ciMethod* _method; // the method |
|
57 ciInstanceKlass* _holder; |
|
58 address _bc_start; // Start of current bytecode for table |
|
59 address _was_wide; // Address past last wide bytecode |
|
60 jint* _table_base; // Aligned start of last table or switch |
|
61 |
|
62 address _start; // Start of bytecodes |
|
63 address _end; // Past end of bytecodes |
|
64 address _pc; // Current PC |
|
65 Bytecodes::Code _bc; // Current bytecode |
|
66 Bytecodes::Code _raw_bc; // Current bytecode, raw form |
|
67 |
|
68 void reset( address base, unsigned int size ) { |
|
69 _bc_start =_was_wide = 0; |
|
70 _start = _pc = base; _end = base + size; |
|
71 } |
|
72 |
|
73 void assert_wide(bool require_wide) const { |
|
74 if (require_wide) |
|
75 { assert(is_wide(), "must be a wide instruction"); } |
|
76 else { assert(!is_wide(), "must not be a wide instruction"); } |
|
77 } |
|
78 |
|
79 Bytecode bytecode() const { return Bytecode(this, _bc_start); } |
|
80 Bytecode next_bytecode() const { return Bytecode(this, _pc); } |
|
81 |
|
82 public: |
|
83 // End-Of-Bytecodes |
|
84 static Bytecodes::Code EOBC() { |
|
85 return Bytecodes::_illegal; |
|
86 } |
|
87 |
|
88 ciBytecodeStream(ciMethod* m) { |
|
89 reset_to_method(m); |
|
90 } |
|
91 |
|
92 ciBytecodeStream() { |
|
93 reset_to_method(NULL); |
|
94 } |
|
95 |
|
96 ciMethod* method() const { return _method; } |
|
97 |
|
98 void reset_to_method(ciMethod* m) { |
|
99 _method = m; |
|
100 if (m == NULL) { |
|
101 _holder = NULL; |
|
102 reset(NULL, 0); |
|
103 } else { |
|
104 _holder = m->holder(); |
|
105 reset(m->code(), m->code_size()); |
|
106 } |
|
107 } |
|
108 |
|
109 void reset_to_bci( int bci ); |
|
110 |
|
111 // Force the iterator to report a certain bci. |
|
112 void force_bci(int bci); |
|
113 |
|
114 void set_max_bci( int max ) { |
|
115 _end = _start + max; |
|
116 } |
|
117 |
|
118 address cur_bcp() const { return _bc_start; } // Returns bcp to current instruction |
|
119 int next_bci() const { return _pc - _start; } |
|
120 int cur_bci() const { return _bc_start - _start; } |
|
121 int instruction_size() const { return _pc - _bc_start; } |
|
122 |
|
123 Bytecodes::Code cur_bc() const{ return check_java(_bc); } |
|
124 Bytecodes::Code cur_bc_raw() const { return check_defined(_raw_bc); } |
|
125 Bytecodes::Code next_bc() { return Bytecodes::java_code((Bytecodes::Code)* _pc); } |
|
126 |
|
127 // Return current ByteCode and increment PC to next bytecode, skipping all |
|
128 // intermediate constants. Returns EOBC at end. |
|
129 // Expected usage: |
|
130 // ciBytecodeStream iter(m); |
|
131 // while (iter.next() != ciBytecodeStream::EOBC()) { ... } |
|
132 Bytecodes::Code next() { |
|
133 _bc_start = _pc; // Capture start of bc |
|
134 if( _pc >= _end ) return EOBC(); // End-Of-Bytecodes |
|
135 |
|
136 // Fetch Java bytecode |
|
137 // All rewritten bytecodes maintain the size of original bytecode. |
|
138 _bc = Bytecodes::java_code(_raw_bc = (Bytecodes::Code)*_pc); |
|
139 int csize = Bytecodes::length_for(_bc); // Expected size |
|
140 _pc += csize; // Bump PC past bytecode |
|
141 if (csize == 0) { |
|
142 _bc = next_wide_or_table(_bc); |
|
143 } |
|
144 return check_java(_bc); |
|
145 } |
|
146 |
|
147 bool is_wide() const { return ( _pc == _was_wide ); } |
|
148 |
|
149 // Does this instruction contain an index which refes into the CP cache? |
|
150 bool has_cache_index() const { return Bytecodes::uses_cp_cache(cur_bc_raw()); } |
|
151 |
|
152 bool has_optional_appendix() { return Bytecodes::has_optional_appendix(cur_bc_raw()); } |
|
153 |
|
154 int get_index_u1() const { |
|
155 return bytecode().get_index_u1(cur_bc_raw()); |
|
156 } |
|
157 |
|
158 int get_index_u1_cpcache() const { |
|
159 return bytecode().get_index_u1_cpcache(cur_bc_raw()); |
|
160 } |
|
161 |
|
162 // Get a byte index following this bytecode. |
|
163 // If prefixed with a wide bytecode, get a wide index. |
|
164 int get_index() const { |
|
165 assert(!has_cache_index(), "else use cpcache variant"); |
|
166 return (_pc == _was_wide) // was widened? |
|
167 ? get_index_u2(true) // yes, return wide index |
|
168 : get_index_u1(); // no, return narrow index |
|
169 } |
|
170 |
|
171 // Get 2-byte index (byte swapping depending on which bytecode) |
|
172 int get_index_u2(bool is_wide = false) const { |
|
173 return bytecode().get_index_u2(cur_bc_raw(), is_wide); |
|
174 } |
|
175 |
|
176 // Get 2-byte index in native byte order. (Rewriter::rewrite makes these.) |
|
177 int get_index_u2_cpcache() const { |
|
178 return bytecode().get_index_u2_cpcache(cur_bc_raw()); |
|
179 } |
|
180 |
|
181 // Get 4-byte index, for invokedynamic. |
|
182 int get_index_u4() const { |
|
183 return bytecode().get_index_u4(cur_bc_raw()); |
|
184 } |
|
185 |
|
186 bool has_index_u4() const { |
|
187 return bytecode().has_index_u4(cur_bc_raw()); |
|
188 } |
|
189 |
|
190 // Get dimensions byte (multinewarray) |
|
191 int get_dimensions() const { return *(unsigned char*)(_pc-1); } |
|
192 |
|
193 // Sign-extended index byte/short, no widening |
|
194 int get_constant_u1() const { return bytecode().get_constant_u1(instruction_size()-1, cur_bc_raw()); } |
|
195 int get_constant_u2(bool is_wide = false) const { return bytecode().get_constant_u2(instruction_size()-2, cur_bc_raw(), is_wide); } |
|
196 |
|
197 // Get a byte signed constant for "iinc". Invalid for other bytecodes. |
|
198 // If prefixed with a wide bytecode, get a wide constant |
|
199 int get_iinc_con() const {return (_pc==_was_wide) ? (jshort) get_constant_u2(true) : (jbyte) get_constant_u1();} |
|
200 |
|
201 // 2-byte branch offset from current pc |
|
202 int get_dest() const { |
|
203 return cur_bci() + bytecode().get_offset_s2(cur_bc_raw()); |
|
204 } |
|
205 |
|
206 // 2-byte branch offset from next pc |
|
207 int next_get_dest() const { |
|
208 assert(_pc < _end, ""); |
|
209 return next_bci() + next_bytecode().get_offset_s2(Bytecodes::_ifeq); |
|
210 } |
|
211 |
|
212 // 4-byte branch offset from current pc |
|
213 int get_far_dest() const { |
|
214 return cur_bci() + bytecode().get_offset_s4(cur_bc_raw()); |
|
215 } |
|
216 |
|
217 // For a lookup or switch table, return target destination |
|
218 int get_int_table( int index ) const { |
|
219 return Bytes::get_Java_u4((address)&_table_base[index]); } |
|
220 |
|
221 // For tableswitch - get length of offset part |
|
222 int get_tableswitch_length() { return get_int_table(2)-get_int_table(1)+1; } |
|
223 |
|
224 int get_dest_table( int index ) const { |
|
225 return cur_bci() + get_int_table(index); } |
|
226 |
|
227 // --- Constant pool access --- |
|
228 int get_constant_raw_index() const; |
|
229 int get_constant_pool_index() const; |
|
230 int get_constant_cache_index() const; |
|
231 int get_field_index(); |
|
232 int get_method_index(); |
|
233 |
|
234 // If this bytecode is a new, newarray, multianewarray, instanceof, |
|
235 // or checkcast, get the referenced klass. |
|
236 ciKlass* get_klass(bool& will_link); |
|
237 int get_klass_index() const; |
|
238 |
|
239 // If this bytecode is one of the ldc variants, get the referenced |
|
240 // constant. Do not attempt to resolve it, since that would require |
|
241 // execution of Java code. If it is not resolved, return an unloaded |
|
242 // object (ciConstant.as_object()->is_loaded() == false). |
|
243 ciConstant get_constant(); |
|
244 constantTag get_constant_pool_tag(int index) const; |
|
245 |
|
246 // True if the klass-using bytecode points to an unresolved klass |
|
247 bool is_unresolved_klass() const { |
|
248 constantTag tag = get_constant_pool_tag(get_klass_index()); |
|
249 return tag.is_unresolved_klass(); |
|
250 } |
|
251 |
|
252 // If this bytecode is one of get_field, get_static, put_field, |
|
253 // or put_static, get the referenced field. |
|
254 ciField* get_field(bool& will_link); |
|
255 |
|
256 ciInstanceKlass* get_declared_field_holder(); |
|
257 int get_field_holder_index(); |
|
258 int get_field_signature_index(); |
|
259 |
|
260 ciMethod* get_method(bool& will_link, ciSignature* *declared_signature_result); |
|
261 bool has_appendix(); |
|
262 ciObject* get_appendix(); |
|
263 bool has_method_type(); |
|
264 ciMethodType* get_method_type(); |
|
265 ciKlass* get_declared_method_holder(); |
|
266 int get_method_holder_index(); |
|
267 int get_method_signature_index(const constantPoolHandle& cpool); |
|
268 |
|
269 // Get the resolved references arrays from the constant pool |
|
270 ciObjArray* get_resolved_references(); |
|
271 }; |
|
272 |
|
273 |
|
274 // ciSignatureStream |
|
275 // |
|
276 // The class is used to iterate over the elements of a method signature. |
|
277 class ciSignatureStream : public StackObj { |
|
278 private: |
|
279 ciSignature* _sig; |
|
280 int _pos; |
|
281 // holder is a method's holder |
|
282 ciKlass* _holder; |
|
283 public: |
|
284 ciSignatureStream(ciSignature* signature, ciKlass* holder = NULL) { |
|
285 _sig = signature; |
|
286 _pos = 0; |
|
287 _holder = holder; |
|
288 } |
|
289 |
|
290 bool at_return_type() { return _pos == _sig->count(); } |
|
291 |
|
292 bool is_done() { return _pos > _sig->count(); } |
|
293 |
|
294 void next() { |
|
295 if (_pos <= _sig->count()) { |
|
296 _pos++; |
|
297 } |
|
298 } |
|
299 |
|
300 ciType* type() { |
|
301 if (at_return_type()) { |
|
302 return _sig->return_type(); |
|
303 } else { |
|
304 return _sig->type_at(_pos); |
|
305 } |
|
306 } |
|
307 |
|
308 // next klass in the signature |
|
309 ciKlass* next_klass() { |
|
310 ciKlass* sig_k; |
|
311 if (_holder != NULL) { |
|
312 sig_k = _holder; |
|
313 _holder = NULL; |
|
314 } else { |
|
315 while (!type()->is_klass()) { |
|
316 next(); |
|
317 } |
|
318 assert(!at_return_type(), "passed end of signature"); |
|
319 sig_k = type()->as_klass(); |
|
320 next(); |
|
321 } |
|
322 return sig_k; |
|
323 } |
|
324 }; |
|
325 |
|
326 |
|
327 // ciExceptionHandlerStream |
|
328 // |
|
329 // The class is used to iterate over the exception handlers of |
|
330 // a method. |
|
331 class ciExceptionHandlerStream : public StackObj { |
|
332 private: |
|
333 // The method whose handlers we are traversing |
|
334 ciMethod* _method; |
|
335 |
|
336 // Our current position in the list of handlers |
|
337 int _pos; |
|
338 int _end; |
|
339 |
|
340 ciInstanceKlass* _exception_klass; |
|
341 int _bci; |
|
342 bool _is_exact; |
|
343 |
|
344 public: |
|
345 ciExceptionHandlerStream(ciMethod* method) { |
|
346 _method = method; |
|
347 |
|
348 // Force loading of method code and handlers. |
|
349 _method->code(); |
|
350 |
|
351 _pos = 0; |
|
352 _end = _method->_handler_count; |
|
353 _exception_klass = NULL; |
|
354 _bci = -1; |
|
355 _is_exact = false; |
|
356 } |
|
357 |
|
358 ciExceptionHandlerStream(ciMethod* method, int bci, |
|
359 ciInstanceKlass* exception_klass = NULL, |
|
360 bool is_exact = false) { |
|
361 _method = method; |
|
362 |
|
363 // Force loading of method code and handlers. |
|
364 _method->code(); |
|
365 |
|
366 _pos = -1; |
|
367 _end = _method->_handler_count + 1; // include the rethrow handler |
|
368 _exception_klass = (exception_klass != NULL && exception_klass->is_loaded() |
|
369 ? exception_klass |
|
370 : NULL); |
|
371 _bci = bci; |
|
372 assert(_bci >= 0, "bci out of range"); |
|
373 _is_exact = is_exact; |
|
374 next(); |
|
375 } |
|
376 |
|
377 // These methods are currently implemented in an odd way. |
|
378 // Count the number of handlers the iterator has ever produced |
|
379 // or will ever produce. Do not include the final rethrow handler. |
|
380 // That is, a trivial exception handler stream will have a count |
|
381 // of zero and produce just the rethrow handler. |
|
382 int count(); |
|
383 |
|
384 // Count the number of handlers this stream will produce from now on. |
|
385 // Include the current handler, and the final rethrow handler. |
|
386 // The remaining count will be zero iff is_done() is true, |
|
387 int count_remaining(); |
|
388 |
|
389 bool is_done() { |
|
390 return (_pos >= _end); |
|
391 } |
|
392 |
|
393 void next() { |
|
394 _pos++; |
|
395 if (_bci != -1) { |
|
396 // We are not iterating over all handlers... |
|
397 while (!is_done()) { |
|
398 ciExceptionHandler* handler = _method->_exception_handlers[_pos]; |
|
399 if (handler->is_in_range(_bci)) { |
|
400 if (handler->is_catch_all()) { |
|
401 // Found final active catch block. |
|
402 _end = _pos+1; |
|
403 return; |
|
404 } else if (_exception_klass == NULL || !handler->catch_klass()->is_loaded()) { |
|
405 // We cannot do any type analysis here. Must conservatively assume |
|
406 // catch block is reachable. |
|
407 return; |
|
408 } else if (_exception_klass->is_subtype_of(handler->catch_klass())) { |
|
409 // This catch clause will definitely catch the exception. |
|
410 // Final candidate. |
|
411 _end = _pos+1; |
|
412 return; |
|
413 } else if (!_is_exact && |
|
414 handler->catch_klass()->is_subtype_of(_exception_klass)) { |
|
415 // This catch block may be reachable. |
|
416 return; |
|
417 } |
|
418 } |
|
419 |
|
420 // The catch block was not pertinent. Go on. |
|
421 _pos++; |
|
422 } |
|
423 } else { |
|
424 // This is an iteration over all handlers. |
|
425 return; |
|
426 } |
|
427 } |
|
428 |
|
429 ciExceptionHandler* handler() { |
|
430 return _method->_exception_handlers[_pos]; |
|
431 } |
|
432 }; |
|
433 |
|
434 |
|
435 |
|
436 // Implementation for declarations in bytecode.hpp |
|
437 Bytecode::Bytecode(const ciBytecodeStream* stream, address bcp): _bcp(bcp != NULL ? bcp : stream->cur_bcp()), _code(Bytecodes::code_at(NULL, addr_at(0))) {} |
|
438 Bytecode_lookupswitch::Bytecode_lookupswitch(const ciBytecodeStream* stream): Bytecode(stream) { verify(); } |
|
439 Bytecode_tableswitch::Bytecode_tableswitch(const ciBytecodeStream* stream): Bytecode(stream) { verify(); } |
|
440 |
|
441 #endif // SHARE_VM_CI_CISTREAMS_HPP |